int main()
{
    int arr[20];
    int i, n, ep;

    prints("Enter the number of integers n: ");
    n = readi(&ep);
    prints("You entered n = ");
    printi(n);
    prints("\n");

    prints("Enter n integers: ");
    for(i=0; i<n; i++) arr[i] = readi(&ep);
    sort(arr,n);

    prints("The n integers in ascending order: ");
    for(i=0; i<n; i++)
    {
        printi(arr[i]);
        prints(" ");
    }
    prints("\n");

    return 0;
}

int main(){
  int mat[100][100];
  char *c="\nPlease Enter Dimension of matrixr: ";
  char *d="\nPlease Enter the matrix row-wise: ";
  char *e="\nThe Entered matrix is: ";
  char *f="\nThe Transposed matrix is: ";
  char *sp=" ";
  char *ne="\n";
  prints(c);
  int err,n,i,j,k;
  n = readi(&err);
  int temp;
  prints(d);
  for (i = 0; i < n; ++i)
  {
    for (j = 0; j < n; ++j)
    {
      mat[i][j]=readi(&err);
    }
  }
  prints(e);
  prints(ne);
  for (i = 0; i < n; ++i)
  {
    prints(ne);
    for (j = 0; j < n; ++j)
    {
      printi(mat[i][j]);
      prints(sp);
    }
  }
  prints(f);
  prints(ne);

  for (i = 0; i < n; ++i)
  {
    for (j = i+1; j < n; ++j)
    {
      temp=mat[j][i];
      mat[j][i]=mat[i][j];
      mat[i][j]=temp;
    }
    
  }
  for (i = 0; i < n; ++i)
  {
    prints(ne);
    for (j = 0; j < n; ++j)
    {
      printi(mat[i][j]);
      prints(sp);
    }
  }
  prints(ne);
return 0;
}

/* Driver program to test above function */
int main()
{
  int arr[50], n, i, err;
  prints("Longest Increasing Subsequence\n");
  prints("Enter number of elements ( < 50)\n");
  n = readi(&err);
  prints("Enter array elements\n");
  for(i = 0; i < n; i++) arr[i] = readi(&err);
  prints("Length of LIS is "); printi(lis( arr, n ) ); prints("\n");
  return 0;
}

// Write a new directory entry (name, inum) into the directory dp.
int
dirlink(struct inode *dp, char *name, uint inum)
{
  int off;
  struct dirent de;
  struct inode *ip;

  // Check that name is not present.
  if((ip = dirlookup(dp, name, 0)) != 0){
    iput(ip);
    return -1;
  }

  // Look for an empty dirent.
  for(off = 0; off < dp->size; off += sizeof(de)){
    if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
      panic("dirlink read");
    if(de.inum == 0)
      break;
  }

  strncpy(de.name, name, DIRSIZ);
  de.inum = inum;
  if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
    panic("dirlink");
  
  return 0;
}

// Load a program segment into pgdir.  addr must be page-aligned
// and the pages from addr to addr+sz must already be mapped.
int
//20160313--
loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
//loaduvm(pde_t *pgdir, char *addr, uint offset, uint sz)
{
//20160313--
  uint i, pa, n;
  pte_t *pte;

  if((uint) addr % PGSIZE != 0)
    panic("loaduvm: addr must be page aligned");
  for(i = 0; i < sz; i += PGSIZE){
    if((pte = walkpgdir(pgdir, addr+i, 0)) == 0)
      panic("loaduvm: address should exist");
//20160313--
    pa = PTE_ADDR(*pte);
//20160313--
    if(sz - i < PGSIZE)
      n = sz - i;
    else
      n = PGSIZE;
//20160313--
    if(readi(ip, p2v(pa), offset+i, n) != n)
      return -1;
  }
  return 0;
}

// Load a program segment into pgdir.  addr must be page-aligned
// and the pages from addr to addr+sz must already be mapped.
int loaduvm (pgd_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz)
{
    uint i, pa, n;
    pte_t *pte;

    if ((uint64) addr % PTE_SZ != 0) {
        panic("loaduvm: addr must be page aligned");
    }

    for (i = 0; i < sz; i += PTE_SZ) {
        if ((pte = walkpgdir(pgdir, addr + i, 0)) == 0) {
            panic("loaduvm: address should exist");
        }

        pa = PTE_ADDR(*pte);

        if (sz - i < PTE_SZ) {
            n = sz - i;
        } else {
            n = PTE_SZ;
        }

        if (readi(ip, p2v(pa), offset + i, n) != n) {
            return -1;
        }
    }

    return 0;
}

int main()
{
    int a,b;
    int *e;
    
    prints("***********************Some random outputs!!*************************\n");
    
    b = 3;
    e = &b;

    prints("Passing pointers to function f!\n");
    prints("Value passed to function: ");
    printi(b);
    prints("\n");
    a = f(e);
    prints("Value returned from function s is: ");
    printi(a);
    prints("\n");
    
    prints("Read an integer!!");
    prints("\n");
    b = readi(e);
    prints("The integer that was read is:");
    printi(b);
    prints("\n");
    
    return 0;
}

//A test file to test the library functions written
int main()
{
    int n,err=0;
    prints("Write the integer n:");
    n = readi(&err);
    if(err!=ERR)
    {
        prints("The integer read is : ");
        printi(n);
    }
    else
    {
        prints("Wrong Input\n");
    }
    float x;

    prints("\nEnter the decimal number: ");
    err = readf(&x);
    if(err==OK)
    {
        prints("The floating number is :");
        printd(x);
    }
    else
    {
        prints("Wrong Input\n");
    }
    prints("\n");
    return 0;
}

int dirlink(struct inode *dp, char *dirname, uint32_t ino)
{
    if(!ISDIR(dp->mode) || ino < 1) {
        return -1;
    }
    
    if(dirlookup(dp, dirname, 0)) 
        return -1;

    struct dirent dir;
    int off;
    for(off = 0; off < dp->size; off+=sizeof(struct dirent))
    {
        if(!readi(dp, (char *)&dir, off, sizeof(struct dirent))) {
            return -1;
        }
        // found a new entry
        if(!dir.ino)
            break;
    }
    
    dir.ino = ino;
    strcpy(dir.name, dirname);
    writei(dp, (char *)&dir, off, sizeof(struct dirent));
    return 0;
}

// Look for a directory entry in a directory.
// If found, set *poff to byte offset of entry.
struct inode*
dirlookup(struct inode *dp, char *name, uint *poff)
{
  uint off, inum;
  struct dirent de;

  if(dp->type != T_DIR)
    panic("dirlookup not DIR");

  for(off = 0; off < dp->size; off += sizeof(de)){
    if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
      panic("dirlink read");
    if(de.inum == 0)
      continue;
    if(namecmp(name, de.name) == 0){
      // entry matches path element
      if(poff)
        *poff = off;
      inum = de.inum;
      return iget(dp->dev, inum);
    }
  }

  return 0;
}

// Read from file f.
int
fileread(struct file *f, char *addr, int n) {
	int r;

	if (f->readable == 0) {
		return -1;
	}

	if (f->type == FD_PIPE) {
		return piperead(f->pipe, addr, n);
	}

	if (f->type == FD_INODE) {
		ilock(f->ip);

		if ((r = readi(f->ip, addr, f->off, n)) > 0) {
			f->off += r;
		}

		iunlock(f->ip);
		return r;
	}

	panic("fileread");
}

void
log_initialize()
{
  struct inode *ip;
  uchar buffer[512];
  int i, j;
  struct buf *bp;
  struct trans_start t_blk;

  for(j=0;j<512;j++)
    buffer[j] = 0;

  ip = iget(1, 3);
  ilock(ip);
  if(ip->size < 512*20){
    cprintf("Creating Journal...\n");
    for(i=0;i<20;i++){
      writei(ip, buffer, i*512, sizeof(buffer));
    }
  }
  else {
    readi(ip, &t_blk, 0, sizeof(t_blk));

    if(t_blk.state == LOGGING){
      cprintf("Inconsistency found in file system. Attempting to recover.\n");

      for(i = 0; i < t_blk.num_blks; i++){
    	  readi(ip, buffer, i*512+512, sizeof(buffer));
    	  bp = bread(1, t_blk.sector[i]);
    	  cprintf("Recovering data in sector: %d\n", t_blk.sector[i]);
    	  memmove(bp->data, buffer, sizeof(buffer));
    	  bwrite(bp);
    	  brelse(bp);
      }

      writei(ip, buffer, 0, sizeof(buffer));
      cprintf("Recovery Complete.\n");
    }
  }

  iunlock(ip);
}

int main(){
	int n1,result;int *ep;int temp;
	prints("Program to calculate factorial of a number:\n");
	prints("Enter n1:");
	n1=readi();
	result=factorial(n1);
	prints("The factorial of the given number is:");
	printi(result);
	prints("\n");
	return 0;
}

void
j_init()
{
  struct inode *ip;
  uchar buffer[512];
  int i, j;
  struct buf *bp;
  struct t_start_blk t_blk;
  
  for(j=0;j<512;j++)
    buffer[j] = 0;
  
  ip = iget(1, 3);
  ilock(ip);
  if(ip->size < 512*20){ 
    cprintf("alloc journal\n");
    // allocate journal if too small
    for(i=0;i<20;i++){
      writei(ip, buffer, i*512, sizeof(buffer));
    }
  }
  else {
    readi(ip, &t_blk, 0, sizeof(t_blk));
    // check if there is a valid not commited transaction
    if(t_blk.state == READY){
      cprintf("~~~~~~~~~~RECOVERING!!!!!~~~~~~~~~~\n");
      for(i = 0; i < t_blk.num_blks; i++){
	readi(ip, buffer, i*512+512, sizeof(buffer));
	bp = bread(1, t_blk.sector[i]);
	cprintf("recovering sector %d\n", t_blk.sector[i]);
	memmove(bp->data, buffer, sizeof(buffer));
	bwrite(bp);
	brelse(bp);
      }
      writei(ip, buffer, 0, sizeof(buffer));
      cprintf("~~~~~RECOVERY COMPLETE~~~~~~~~\n");
    }
  }
  
  iunlock(ip);
}

int main()
{
	int a[100];
	int i;
	int j;
	int n;
	int err;
	prints("Enter the total number of integers to sort :");
	n = readi(&err);
	prints("Enter the number one by one:\n");
	for(i=0;i<n;i++)
	{
		a[i] = readi(&err);
	}

	prints("Sorting the array. \n");
	int temp;
	for(i=n;i>0;i--)
	{
		for(j=0;j<i-1;j++)
		{
			if(a[j+1]<a[j])
			{
				temp = a[j];
				a[j] = a[j+1];
				a[j+1]=temp;
			}
		}
	}
	prints("Printing the sorted array. \n");
	for(i=0;i<n;i++)
	{
		printi(a[i]);
		prints(" ");
	}
	prints("\n");

	return 0;


}

int main()
{
	prints("Enter a number whose factorial you want to know: ")	;
	int n,err;
	n = readi(&err);
	int fact;
	fact = factorial(n);
	prints("The value is: ");
	printi(fact);
	prints("\n");

	prints("Enter a number n whose fibonacci(n) you want to know: ");
	n = readi(&err);
	int fib;
	prints("The value is: ");
	fib = fibonacci(n);
	printi(fib);
	prints("\n");
	return 0;

}

Node::Node(const Block &blk) { // notice here
    char* mem = (char*)malloc(BLOCK_SIZE);
    memcpy(mem, blk.data, BLOCK_SIZE);
    
    isleaf = mem[0]; isroot = mem[1];
    
    mem += 2*sizeof(char);
    int pSize = readi(mem), kSize = readi(mem), typeId = readi(mem), strLen = readi(mem);
    
    //system("pause");
    
    int p = 0;
    
    for( int i = 0; i < pSize; i++ ) {
        p = readi(mem);
        P.push_back(p);
    }
    
    
    for( int i = 0; i < kSize; i++ ) {
        AttrType k;
        
        if( typeId == 0 ) { // int
            k = AttrType(readi(mem));
        }
        else if( typeId == 1 ) { // float
            k = AttrType(readf(mem));
        }
        else if( typeId == 2 ) { // string
            k = AttrType(reads(mem, strLen));
        }
        
        K.push_back(k);
    }
}

int main()
{
	prints("Enter three numbers whose maximum among them you want to know\n");
	int a,b,c,err;
	prints("Enter the first number: ");
	a = readi(&err);
	prints("Enter the second number: ");
	b = readi(&err);
	prints("Enter the third number: ");
	c = readi(&err);

	int max;
	max = findmax(a,b,c);

	prints("The max value is: ");
	printi(max);
	prints("\n");

	prints("Lets do expression tests:\n");
	prints("a = b*c*a = ");
	a = b*c*a;
	printi(a);
	prints("\n");

	prints("b = a/c = ");
	b = a/c;
	printi(b);
	prints("\n");
	
	prints("c = a%b = ");
	c = a%b;
	printi(c);
	prints("\n");
		
	return 0;
}

int16_t _read(void)
{
	inoptr ino;
	uint8_t flag;

	if (!valaddr(buf, nbytes))
	        return -1;
	/* Set up u_base, u_offset, ino; check permissions, file num. */
	if ((ino = rwsetup(true, &flag)) == NULLINODE)
		return -1;	/* bomb out if error */

	readi(ino, flag);
	updoff();

	return (udata.u_count);
}

int main()
{
	float x;
	int y;
	prints("Enter a floating point number :");
	if(!readf(&x))
		printd(x);
	else
		prints("Invalid floating point number!");
	prints("\nEnter an integer :");
	if(!readi(&y))
		printi(y);
	else
		prints("Invalid integer!");
	prints("\n");
	return 0;
}