_usertests:     file format elf32-i386

Disassembly of section .text:

00000000 <opentest>:
// simple file system tests

void
opentest(void)
{
       0:	55                   	push   %ebp
  int fd;

  printf(stdout, "open test\n");
       1:	b8 dc 31 00 00       	mov    $0x31dc,%eax
       6:	89 e5                	mov    %esp,%ebp
       8:	83 ec 08             	sub    $0x8,%esp
       b:	89 44 24 04          	mov    %eax,0x4(%esp)
       f:	a1 54 44 00 00       	mov    0x4454,%eax
      14:	89 04 24             	mov    %eax,(%esp)
      17:	e8 d4 2e 00 00       	call   2ef0 <printf>
  fd = open("echo", 0);
      1c:	31 c0                	xor    %eax,%eax
      1e:	89 44 24 04          	mov    %eax,0x4(%esp)
      22:	c7 04 24 e7 31 00 00 	movl   $0x31e7,(%esp)
      29:	e8 9e 2d 00 00       	call   2dcc <open>
  if(fd < 0){
      2e:	85 c0                	test   %eax,%eax
      30:	78 36                	js     68 <opentest+0x68>
    printf(stdout, "open echo failed!\n");
    exit();
  }
  close(fd);
      32:	89 04 24             	mov    %eax,(%esp)
      35:	e8 7a 2d 00 00       	call   2db4 <close>
  fd = open("doesnotexist", 0);
      3a:	31 c9                	xor    %ecx,%ecx
      3c:	89 4c 24 04          	mov    %ecx,0x4(%esp)
      40:	c7 04 24 ff 31 00 00 	movl   $0x31ff,(%esp)
      47:	e8 80 2d 00 00       	call   2dcc <open>
  if(fd >= 0){
      4c:	85 c0                	test   %eax,%eax
      4e:	79 33                	jns    83 <opentest+0x83>
    printf(stdout, "open doesnotexist succeeded!\n");
    exit();
  }
  printf(stdout, "open test ok\n");
      50:	b8 2a 32 00 00       	mov    $0x322a,%eax
      55:	89 44 24 04          	mov    %eax,0x4(%esp)
      59:	a1 54 44 00 00       	mov    0x4454,%eax
      5e:	89 04 24             	mov    %eax,(%esp)
      61:	e8 8a 2e 00 00       	call   2ef0 <printf>
}
      66:	c9                   	leave  
      67:	c3                   	ret    
      68:	b8 ec 31 00 00       	mov    $0x31ec,%eax
      6d:	89 44 24 04          	mov    %eax,0x4(%esp)
      71:	a1 54 44 00 00       	mov    0x4454,%eax
      76:	89 04 24             	mov    %eax,(%esp)
      79:	e8 72 2e 00 00       	call   2ef0 <printf>
      7e:	e8 09 2d 00 00       	call   2d8c <exit>
      83:	a1 54 44 00 00       	mov    0x4454,%eax
      88:	ba 0c 32 00 00       	mov    $0x320c,%edx
      8d:	89 54 24 04          	mov    %edx,0x4(%esp)
      91:	89 04 24             	mov    %eax,(%esp)
      94:	e8 57 2e 00 00       	call   2ef0 <printf>
      99:	e8 ee 2c 00 00       	call   2d8c <exit>
      9e:	89 f6                	mov    %esi,%esi

000000a0 <forktest>:

void
writetest(void)
{
  int fd;
  int i;

  printf(stdout, "small file test\n");
  fd = open("small", O_CREATE|O_RDWR);
  if(fd >= 0){
    printf(stdout, "creat small succeeded; ok\n");
  } else {
    printf(stdout, "error: creat small failed!\n");
    exit();
  }
  for(i = 0; i < 100; i++) {
    if(write(fd, "aaaaaaaaaa", 10) != 10) {
      printf(stdout, "error: write aa %d new file failed\n", i);
      exit();
    }
    if(write(fd, "bbbbbbbbbb", 10) != 10) {
      printf(stdout, "error: write bb %d new file failed\n", i);
      exit();
    }
  }
  printf(stdout, "writes ok\n");
  close(fd);
  fd = open("small", O_RDONLY);
  if(fd >= 0){
    printf(stdout, "open small succeeded ok\n");
  } else {
    printf(stdout, "error: open small failed!\n");
    exit();
  }
  i = read(fd, buf, 2000);
  if(i == 2000) {
    printf(stdout, "read succeeded ok\n");
  } else {
    printf(stdout, "read failed\n");
    exit();
  }
  close(fd);

  if(unlink("small") < 0) {
    printf(stdout, "unlink small failed\n");
    exit();
  }
  printf(stdout, "small file test ok\n");
}

void
writetest1(void)
{
  int i, fd, n;

  printf(stdout, "big files test\n");

  fd = open("big", O_CREATE|O_RDWR);
  if(fd < 0){
    printf(stdout, "error: creat big failed!\n");
    exit();
  }

  for(i = 0; i < MAXFILE; i++) {
    ((int*) buf)[0] = i;
    if(write(fd, buf, 512) != 512) {
      printf(stdout, "error: write big file failed\n", i);
      exit();
    }
  }

  close(fd);

  fd = open("big", O_RDONLY);
  if(fd < 0){
    printf(stdout, "error: open big failed!\n");
    exit();
  }

  n = 0;
  for(;;) {
    i = read(fd, buf, 512);
    if(i == 0) {
      if(n == MAXFILE - 1) {
        printf(stdout, "read only %d blocks from big", n);
        exit();
      }
      break;
    } else if(i != 512) {
      printf(stdout, "read failed %d\n", i);
      exit();
    }
    if(((int*)buf)[0] != n) {
      printf(stdout, "read content of block %d is %d\n",
             n, ((int*)buf)[0]);
      exit();
    }
    n++;
  }
  close(fd);
  if(unlink("big") < 0) {
    printf(stdout, "unlink big failed\n");
    exit();
  }
  printf(stdout, "big files ok\n");
}

void
createtest(void)
{
  int i, fd;

  printf(stdout, "many creates, followed by unlink test\n");

  name[0] = 'a';
  name[2] = '\0';
  for(i = 0; i < 52; i++) {
    name[1] = '0' + i;
    fd = open(name, O_CREATE|O_RDWR);
    close(fd);
  }
  name[0] = 'a';
  name[2] = '\0';
  for(i = 0; i < 52; i++) {
    name[1] = '0' + i;
    unlink(name);
  }
  printf(stdout, "many creates, followed by unlink; ok\n");
}

void dirtest(void)
{
  printf(stdout, "mkdir test\n");

  if(mkdir("dir0") < 0) {
    printf(stdout, "mkdir failed\n");
    exit();
  }

  if(chdir("dir0") < 0) {
    printf(stdout, "chdir dir0 failed\n");
    exit();
  }

  if(chdir("..") < 0) {
    printf(stdout, "chdir .. failed\n");
    exit();
  }

  if(unlink("dir0") < 0) {
    printf(stdout, "unlink dir0 failed\n");
    exit();
  }
  printf(stdout, "mkdir test\n");
}

void
exectest(void)
{
  printf(stdout, "exec test\n");
  if(exec("echo", echo_args) < 0) {
    printf(stdout, "exec echo failed\n");
    exit();
  }
}

// simple fork and pipe read/write

void
pipe1(void)
{
  int fds[2], pid;
  int seq, i, n, cc, total;

  if(pipe(fds) != 0){
    printf(1, "pipe() failed\n");
    exit();
  }
  pid = fork();
  seq = 0;
  if(pid == 0){
    close(fds[0]);
    for(n = 0; n < 5; n++){
      for(i = 0; i < 1033; i++)
        buf[i] = seq++;
      if(write(fds[1], buf, 1033) != 1033){
        printf(1, "pipe1 oops 1\n");
        exit();
      }
    }
    exit();
  } else if(pid > 0){
    close(fds[1]);
    total = 0;
    cc = 1;
    while((n = read(fds[0], buf, cc)) > 0){
      for(i = 0; i < n; i++){
        if((buf[i] & 0xff) != (seq++ & 0xff)){
          printf(1, "pipe1 oops 2\n");
          return;
        }
      }
      total += n;
      cc = cc * 2;
      if(cc > sizeof(buf))
        cc = sizeof(buf);
    }
    if(total != 5 * 1033)
      printf(1, "pipe1 oops 3 total %d\n", total);
    close(fds[0]);
    wait();
  } else {
    printf(1, "fork() failed\n");
    exit();
  }
  printf(1, "pipe1 ok\n");
}

// meant to be run w/ at most two CPUs
void
preempt(void)
{
  int pid1, pid2, pid3;
  int pfds[2];

  printf(1, "preempt: ");
  pid1 = fork();
  if(pid1 == 0)
    for(;;)
      ;

  pid2 = fork();
  if(pid2 == 0)
    for(;;)
      ;

  pipe(pfds);
  pid3 = fork();
  if(pid3 == 0){
    close(pfds[0]);
    if(write(pfds[1], "x", 1) != 1)
      printf(1, "preempt write error");
    close(pfds[1]);
    for(;;)
      ;
  }

  close(pfds[1]);
  if(read(pfds[0], buf, sizeof(buf)) != 1){
    printf(1, "preempt read error");
    return;
  }
  close(pfds[0]);
  printf(1, "kill... ");
  kill(pid1);
  kill(pid2);
  kill(pid3);
  printf(1, "wait... ");
  wait();
  wait();
  wait();
  printf(1, "preempt ok\n");
}

// try to find any races between exit and wait
void
exitwait(void)
{
  int i, pid;

  for(i = 0; i < 100; i++){
    pid = fork();
    if(pid < 0){
      printf(1, "fork failed\n");
      return;
    }
    if(pid){
      if(wait() != pid){
        printf(1, "wait wrong pid\n");
        return;
      }
    } else {
      exit();
    }
  }
  printf(1, "exitwait ok\n");
}

void
mem(void)
{
  void *m1, *m2;
  int pid;

  if((pid = fork()) == 0){
    m1 = 0;
    while((m2 = malloc(10001)) != 0) {
      *(char**) m2 = m1;
      m1 = m2;
    }
    while(m1) {
      m2 = *(char**)m1;
      free(m1);
      m1 = m2;
    }
    m1 = malloc(1024*20);
    if(m1 == 0) {
      printf(1, "couldn't allocate mem?!!\n");
      exit();
    }
    free(m1);
    printf(1, "mem ok\n");
    exit();
  } else {
    wait();
  }
}

// More file system tests

// two processes write to the same file descriptor
// is the offset shared? does inode locking work?
void
sharedfd(void)
{
  int fd, pid, i, n, nc, np;
  char buf[10];

  unlink("sharedfd");
  fd = open("sharedfd", O_CREATE|O_RDWR);
  if(fd < 0){
    printf(1, "fstests: cannot open sharedfd for writing");
    return;
  }
  pid = fork();
  memset(buf, pid==0?'c':'p', sizeof(buf));
  for(i = 0; i < 1000; i++){
    if(write(fd, buf, sizeof(buf)) != sizeof(buf)){
      printf(1, "fstests: write sharedfd failed\n");
      break;
    }
  }
  if(pid == 0)
    exit();
  else
    wait();
  close(fd);
  fd = open("sharedfd", 0);
  if(fd < 0){
    printf(1, "fstests: cannot open sharedfd for reading\n");
    return;
  }
  nc = np = 0;
  while((n = read(fd, buf, sizeof(buf))) > 0){
    for(i = 0; i < sizeof(buf); i++){
      if(buf[i] == 'c')
        nc++;
      if(buf[i] == 'p')
        np++;
    }
  }
  close(fd);
  unlink("sharedfd");
  if(nc == 10000 && np == 10000)
    printf(1, "sharedfd ok\n");
  else
    printf(1, "sharedfd oops %d %d\n", nc, np);
}

// two processes write two different files at the same
// time, to test block allocation.
void
twofiles(void)
{
  int fd, pid, i, j, n, total;
  char *fname;

  printf(1, "twofiles test\n");

  unlink("f1");
  unlink("f2");

  pid = fork();
  if(pid < 0){
    printf(1, "fork failed\n");
    return;
  }

  fname = pid ? "f1" : "f2";
  fd = open(fname, O_CREATE | O_RDWR);
  if(fd < 0){
    printf(1, "create failed\n");
    exit();
  }

  memset(buf, pid?'p':'c', 512);
  for(i = 0; i < 12; i++){
    if((n = write(fd, buf, 500)) != 500){
      printf(1, "write failed %d\n", n);
      exit();
    }
  }
  close(fd);
  if(pid)
    wait();
  else
    exit();

  for(i = 0; i < 2; i++){
    fd = open(i?"f1":"f2", 0);
    total = 0;
    while((n = read(fd, buf, sizeof(buf))) > 0){
      for(j = 0; j < n; j++){
        if(buf[j] != (i?'p':'c')){
          printf(1, "wrong char\n");
          exit();
        }
      }
      total += n;
    }
    close(fd);
    if(total != 12*500){
      printf(1, "wrong length %d\n", total);
      exit();
    }
  }

  unlink("f1");
  unlink("f2");

  printf(1, "twofiles ok\n");
}

// two processes create and delete different files in same directory
void
createdelete(void)
{
  enum { N = 20 };
  int pid, i, fd;
  char name[32];

  printf(1, "createdelete test\n");
  pid = fork();
  if(pid < 0){
    printf(1, "fork failed\n");
    exit();
  }

  name[0] = pid ? 'p' : 'c';
  name[2] = '\0';
  for(i = 0; i < N; i++){
    name[1] = '0' + i;
    fd = open(name, O_CREATE | O_RDWR);
    if(fd < 0){
      printf(1, "create failed\n");
      exit();
    }
    close(fd);
    if(i > 0 && (i % 2 ) == 0){
      name[1] = '0' + (i / 2);
      if(unlink(name) < 0){
        printf(1, "unlink failed\n");
        exit();
      }
    }
  }

  if(pid==0)
    exit();
  else
    wait();

  for(i = 0; i < N; i++){
    name[0] = 'p';
    name[1] = '0' + i;
    fd = open(name, 0);
    if((i == 0 || i >= N/2) && fd < 0){
      printf(1, "oops createdelete %s didn't exist\n", name);
      exit();
    } else if((i >= 1 && i < N/2) && fd >= 0){
      printf(1, "oops createdelete %s did exist\n", name);
      exit();
    }
    if(fd >= 0)
      close(fd);

    name[0] = 'c';
    name[1] = '0' + i;
    fd = open(name, 0);
    if((i == 0 || i >= N/2) && fd < 0){
      printf(1, "oops createdelete %s didn't exist\n", name);
      exit();
    } else if((i >= 1 && i < N/2) && fd >= 0){
      printf(1, "oops createdelete %s did exist\n", name);
      exit();
    }
    if(fd >= 0)
      close(fd);
  }

  for(i = 0; i < N; i++){
    name[0] = 'p';
    name[1] = '0' + i;
    unlink(name);
    name[0] = 'c';
    unlink(name);
  }

  printf(1, "createdelete ok\n");
}

// can I unlink a file and still read it?
void
unlinkread(void)
{
  int fd, fd1;

  printf(1, "unlinkread test\n");
  fd = open("unlinkread", O_CREATE | O_RDWR);
  if(fd < 0){
    printf(1, "create unlinkread failed\n");
    exit();
  }
  write(fd, "hello", 5);
  close(fd);

  fd = open("unlinkread", O_RDWR);
  if(fd < 0){
    printf(1, "open unlinkread failed\n");
    exit();
  }
  if(unlink("unlinkread") != 0){
    printf(1, "unlink unlinkread failed\n");
    exit();
  }

  fd1 = open("unlinkread", O_CREATE | O_RDWR);
  write(fd1, "yyy", 3);
  close(fd1);

  if(read(fd, buf, sizeof(buf)) != 5){
    printf(1, "unlinkread read failed");
    exit();
  }
  if(buf[0] != 'h'){
    printf(1, "unlinkread wrong data\n");
    exit();
  }
  if(write(fd, buf, 10) != 10){
    printf(1, "unlinkread write failed\n");
    exit();
  }
  close(fd);
  unlink("unlinkread");
  printf(1, "unlinkread ok\n");
}

void
linktest(void)
{
  int fd;

  printf(1, "linktest\n");

  unlink("lf1");
  unlink("lf2");

  fd = open("lf1", O_CREATE|O_RDWR);
  if(fd < 0){
    printf(1, "create lf1 failed\n");
    exit();
  }
  if(write(fd, "hello", 5) != 5){
    printf(1, "write lf1 failed\n");
    exit();
  }
  close(fd);

  if(link("lf1", "lf2") < 0){
    printf(1, "link lf1 lf2 failed\n");
    exit();
  }
  unlink("lf1");

  if(open("lf1", 0) >= 0){
    printf(1, "unlinked lf1 but it is still there!\n");
    exit();
  }

  fd = open("lf2", 0);
  if(fd < 0){
    printf(1, "open lf2 failed\n");
    exit();
  }
  if(read(fd, buf, sizeof(buf)) != 5){
    printf(1, "read lf2 failed\n");
    exit();
  }
  close(fd);

  if(link("lf2", "lf2") >= 0){
    printf(1, "link lf2 lf2 succeeded! oops\n");
    exit();
  }

  unlink("lf2");
  if(link("lf2", "lf1") >= 0){
    printf(1, "link non-existant succeeded! oops\n");
    exit();
  }

  if(link(".", "lf1") >= 0){
    printf(1, "link . lf1 succeeded! oops\n");
    exit();
  }

  printf(1, "linktest ok\n");
}

// test concurrent create and unlink of the same file
void
concreate(void)
{
  char file[3];
  int i, pid, n, fd;
  char fa[40];
  struct {
    ushort inum;
    char name[14];
  } de;

  printf(1, "concreate test\n");
  file[0] = 'C';
  file[2] = '\0';
  for(i = 0; i < 40; i++){
    file[1] = '0' + i;
    unlink(file);
    pid = fork();
    if(pid && (i % 3) == 1){
      link("C0", file);
    } else if(pid == 0 && (i % 5) == 1){
      link("C0", file);
    } else {
      fd = open(file, O_CREATE | O_RDWR);
      if(fd < 0){
        printf(1, "concreate create %s failed\n", file);
        exit();
      }
      close(fd);
    }
    if(pid == 0)
      exit();
    else
      wait();
  }

  memset(fa, 0, sizeof(fa));
  fd = open(".", 0);
  n = 0;
  while(read(fd, &de, sizeof(de)) > 0){
    if(de.inum == 0)
      continue;
    if(de.name[0] == 'C' && de.name[2] == '\0'){
      i = de.name[1] - '0';
      if(i < 0 || i >= sizeof(fa)){
        printf(1, "concreate weird file %s\n", de.name);
        exit();
      }
      if(fa[i]){
        printf(1, "concreate duplicate file %s\n", de.name);
        exit();
      }
      fa[i] = 1;
      n++;
    }
  }
  close(fd);

  if(n != 40){
    printf(1, "concreate not enough files in directory listing\n");
    exit();
  }

  for(i = 0; i < 40; i++){
    file[1] = '0' + i;
    pid = fork();
    if(pid < 0){
      printf(1, "fork failed\n");
      exit();
    }
    if(((i % 3) == 0 && pid == 0) ||
       ((i % 3) == 1 && pid != 0)){
      fd = open(file, 0);
      close(fd);
    } else {
      unlink(file);
    }
    if(pid == 0)
      exit();
    else
      wait();
  }

  printf(1, "concreate ok\n");
}

// directory that uses indirect blocks
void
bigdir(void)
{
  int i, fd;
  char name[10];

  printf(1, "bigdir test\n");
  unlink("bd");

  fd = open("bd", O_CREATE);
  if(fd < 0){
    printf(1, "bigdir create failed\n");
    exit();
  }
  close(fd);

  for(i = 0; i < 500; i++){
    name[0] = 'x';
    name[1] = '0' + (i / 64);
    name[2] = '0' + (i % 64);
    name[3] = '\0';
    if(link("bd", name) != 0){
      printf(1, "bigdir link failed\n");
      exit();
    }
  }

  unlink("bd");
  for(i = 0; i < 500; i++){
    name[0] = 'x';
    name[1] = '0' + (i / 64);
    name[2] = '0' + (i % 64);
    name[3] = '\0';
    if(unlink(name) != 0){
      printf(1, "bigdir unlink failed");
      exit();
    }
  }

  printf(1, "bigdir ok\n");
}

void
subdir(void)
{
  int fd, cc;

  printf(1, "subdir test\n");

  unlink("ff");
  if(mkdir("dd") != 0){
    printf(1, "subdir mkdir dd failed\n");
    exit();
  }

  fd = open("dd/ff", O_CREATE | O_RDWR);
  if(fd < 0){
    printf(1, "create dd/ff failed\n");
    exit();
  }
  write(fd, "ff", 2);
  close(fd);
  
  if(unlink("dd") >= 0){
    printf(1, "unlink dd (non-empty dir) succeeded!\n");
    exit();
  }

  if(mkdir("/dd/dd") != 0){
    printf(1, "subdir mkdir dd/dd failed\n");
    exit();
  }

  fd = open("dd/dd/ff", O_CREATE | O_RDWR);
  if(fd < 0){
    printf(1, "create dd/dd/ff failed\n");
    exit();
  }
  write(fd, "FF", 2);
  close(fd);

  fd = open("dd/dd/../ff", 0);
  if(fd < 0){
    printf(1, "open dd/dd/../ff failed\n");
    exit();
  }
  cc = read(fd, buf, sizeof(buf));
  if(cc != 2 || buf[0] != 'f'){
    printf(1, "dd/dd/../ff wrong content\n");
    exit();
  }
  close(fd);

  if(link("dd/dd/ff", "dd/dd/ffff") != 0){
    printf(1, "link dd/dd/ff dd/dd/ffff failed\n");
    exit();
  }

  if(unlink("dd/dd/ff") != 0){
    printf(1, "unlink dd/dd/ff failed\n");
    exit();
  }
  if(open("dd/dd/ff", O_RDONLY) >= 0){
    printf(1, "open (unlinked) dd/dd/ff succeeded\n");
    exit();
  }

  if(chdir("dd") != 0){
    printf(1, "chdir dd failed\n");
    exit();
  }
  if(chdir("dd/../../dd") != 0){
    printf(1, "chdir dd/../../dd failed\n");
    exit();
  }
  if(chdir("dd/../../../dd") != 0){
    printf(1, "chdir dd/../../dd failed\n");
    exit();
  }
  if(chdir("./..") != 0){
    printf(1, "chdir ./.. failed\n");
    exit();
  }

  fd = open("dd/dd/ffff", 0);
  if(fd < 0){
    printf(1, "open dd/dd/ffff failed\n");
    exit();
  }
  if(read(fd, buf, sizeof(buf)) != 2){
    printf(1, "read dd/dd/ffff wrong len\n");
    exit();
  }
  close(fd);

  if(open("dd/dd/ff", O_RDONLY) >= 0){
    printf(1, "open (unlinked) dd/dd/ff succeeded!\n");
    exit();
  }

  if(open("dd/ff/ff", O_CREATE|O_RDWR) >= 0){
    printf(1, "create dd/ff/ff succeeded!\n");
    exit();
  }
  if(open("dd/xx/ff", O_CREATE|O_RDWR) >= 0){
    printf(1, "create dd/xx/ff succeeded!\n");
    exit();
  }
  if(open("dd", O_CREATE) >= 0){
    printf(1, "create dd succeeded!\n");
    exit();
  }
  if(open("dd", O_RDWR) >= 0){
    printf(1, "open dd rdwr succeeded!\n");
    exit();
  }
  if(open("dd", O_WRONLY) >= 0){
    printf(1, "open dd wronly succeeded!\n");
    exit();
  }
  if(link("dd/ff/ff", "dd/dd/xx") == 0){
    printf(1, "link dd/ff/ff dd/dd/xx succeeded!\n");
    exit();
  }
  if(link("dd/xx/ff", "dd/dd/xx") == 0){
    printf(1, "link dd/xx/ff dd/dd/xx succeeded!\n");
    exit();
  }
  if(link("dd/ff", "dd/dd/ffff") == 0){
    printf(1, "link dd/ff dd/dd/ffff succeeded!\n");
    exit();
  }
  if(mkdir("dd/ff/ff") == 0){
    printf(1, "mkdir dd/ff/ff succeeded!\n");
    exit();
  }
  if(mkdir("dd/xx/ff") == 0){
    printf(1, "mkdir dd/xx/ff succeeded!\n");
    exit();
  }
  if(mkdir("dd/dd/ffff") == 0){
    printf(1, "mkdir dd/dd/ffff succeeded!\n");
    exit();
  }
  if(unlink("dd/xx/ff") == 0){
    printf(1, "unlink dd/xx/ff succeeded!\n");
    exit();
  }
  if(unlink("dd/ff/ff") == 0){
    printf(1, "unlink dd/ff/ff succeeded!\n");
    exit();
  }
  if(chdir("dd/ff") == 0){
    printf(1, "chdir dd/ff succeeded!\n");
    exit();
  }
  if(chdir("dd/xx") == 0){
    printf(1, "chdir dd/xx succeeded!\n");
    exit();
  }

  if(unlink("dd/dd/ffff") != 0){
    printf(1, "unlink dd/dd/ff failed\n");
    exit();
  }
  if(unlink("dd/ff") != 0){
    printf(1, "unlink dd/ff failed\n");
    exit();
  }
  if(unlink("dd") == 0){
    printf(1, "unlink non-empty dd succeeded!\n");
    exit();
  }
  if(unlink("dd/dd") < 0){
    printf(1, "unlink dd/dd failed\n");
    exit();
  }
  if(unlink("dd") < 0){
    printf(1, "unlink dd failed\n");
    exit();
  }

  printf(1, "subdir ok\n");
}

void
bigfile(void)
{
  int fd, i, total, cc;

  printf(1, "bigfile test\n");

  unlink("bigfile");
  fd = open("bigfile", O_CREATE | O_RDWR);
  if(fd < 0){
    printf(1, "cannot create bigfile");
    exit();
  }
  for(i = 0; i < 20; i++){
    memset(buf, i, 600);
    if(write(fd, buf, 600) != 600){
      printf(1, "write bigfile failed\n");
      exit();
    }
  }
  close(fd);

  fd = open("bigfile", 0);
  if(fd < 0){
    printf(1, "cannot open bigfile\n");
    exit();
  }
  total = 0;
  for(i = 0; ; i++){
    cc = read(fd, buf, 300);
    if(cc < 0){
      printf(1, "read bigfile failed\n");
      exit();
    }
    if(cc == 0)
      break;
    if(cc != 300){
      printf(1, "short read bigfile\n");
      exit();
    }
    if(buf[0] != i/2 || buf[299] != i/2){
      printf(1, "read bigfile wrong data\n");
      exit();
    }
    total += cc;
  }
  close(fd);
  if(total != 20*600){
    printf(1, "read bigfile wrong total\n");
    exit();
  }
  unlink("bigfile");

  printf(1, "bigfile test ok\n");
}

void
fourteen(void)
{
  int fd;

  // DIRSIZ is 14.
  printf(1, "fourteen test\n");

  if(mkdir("12345678901234") != 0){
    printf(1, "mkdir 12345678901234 failed\n");
    exit();
  }
  if(mkdir("12345678901234/123456789012345") != 0){
    printf(1, "mkdir 12345678901234/123456789012345 failed\n");
    exit();
  }
  fd = open("123456789012345/123456789012345/123456789012345", O_CREATE);
  if(fd < 0){
    printf(1, "create 123456789012345/123456789012345/123456789012345 failed\n");
    exit();
  }
  close(fd);
  fd = open("12345678901234/12345678901234/12345678901234", 0);
  if(fd < 0){
    printf(1, "open 12345678901234/12345678901234/12345678901234 failed\n");
    exit();
  }
  close(fd);

  if(mkdir("12345678901234/12345678901234") == 0){
    printf(1, "mkdir 12345678901234/12345678901234 succeeded!\n");
    exit();
  }
  if(mkdir("123456789012345/12345678901234") == 0){
    printf(1, "mkdir 12345678901234/123456789012345 succeeded!\n");
    exit();
  }

  printf(1, "fourteen ok\n");
}

void
rmdot(void)
{
  printf(1, "rmdot test\n");
  if(mkdir("dots") != 0){
    printf(1, "mkdir dots failed\n");
    exit();
  }
  if(chdir("dots") != 0){
    printf(1, "chdir dots failed\n");
    exit();
  }
  if(unlink(".") == 0){
    printf(1, "rm . worked!\n");
    exit();
  }
  if(unlink("..") == 0){
    printf(1, "rm .. worked!\n");
    exit();
  }
  if(chdir("/") != 0){
    printf(1, "chdir / failed\n");
    exit();
  }
  if(unlink("dots/.") == 0){
    printf(1, "unlink dots/. worked!\n");
    exit();
  }
  if(unlink("dots/..") == 0){
    printf(1, "unlink dots/.. worked!\n");
    exit();
  }
  if(unlink("dots") != 0){
    printf(1, "unlink dots failed!\n");
    exit();
  }
  printf(1, "rmdot ok\n");
}

void
dirfile(void)
{
  int fd;

  printf(1, "dir vs file\n");

  fd = open("dirfile", O_CREATE);
  if(fd < 0){
    printf(1, "create dirfile failed\n");
    exit();
  }
  close(fd);
  if(chdir("dirfile") == 0){
    printf(1, "chdir dirfile succeeded!\n");
    exit();
  }
  fd = open("dirfile/xx", 0);
  if(fd >= 0){
    printf(1, "create dirfile/xx succeeded!\n");
    exit();
  }
  fd = open("dirfile/xx", O_CREATE);
  if(fd >= 0){
    printf(1, "create dirfile/xx succeeded!\n");
    exit();
  }
  if(mkdir("dirfile/xx") == 0){
    printf(1, "mkdir dirfile/xx succeeded!\n");
    exit();
  }
  if(unlink("dirfile/xx") == 0){
    printf(1, "unlink dirfile/xx succeeded!\n");
    exit();
  }
  if(link("README", "dirfile/xx") == 0){
    printf(1, "link to dirfile/xx succeeded!\n");
    exit();
  }
  if(unlink("dirfile") != 0){
    printf(1, "unlink dirfile failed!\n");
    exit();
  }

  fd = open(".", O_RDWR);
  if(fd >= 0){
    printf(1, "open . for writing succeeded!\n");
    exit();
  }
  fd = open(".", 0);
  if(write(fd, "x", 1) > 0){
    printf(1, "write . succeeded!\n");
    exit();
  }
  close(fd);

  printf(1, "dir vs file OK\n");
}

// test that iput() is called at the end of _namei()
void
iref(void)
{
  int i, fd;

  printf(1, "empty file name\n");

  // the 50 is NINODE
  for(i = 0; i < 50 + 1; i++){
    if(mkdir("irefd") != 0){
      printf(1, "mkdir irefd failed\n");
      exit();
    }
    if(chdir("irefd") != 0){
      printf(1, "chdir irefd failed\n");
      exit();
    }

    mkdir("");
    link("README", "");
    fd = open("", O_CREATE);
    if(fd >= 0)
      close(fd);
    fd = open("xx", O_CREATE);
    if(fd >= 0)
      close(fd);
    unlink("xx");
  }

  chdir("/");
  printf(1, "empty file name OK\n");
}

// test that fork fails gracefully
// the forktest binary also does this, but it runs out of proc entries first.
// inside the bigger usertests binary, we run out of memory first.
void
forktest(void)
{
      a0:	55                   	push   %ebp
  int n, pid;

  printf(1, "fork test\n");
      a1:	b9 38 32 00 00       	mov    $0x3238,%ecx
      a6:	89 e5                	mov    %esp,%ebp
      a8:	53                   	push   %ebx
      a9:	31 db                	xor    %ebx,%ebx
      ab:	83 ec 14             	sub    $0x14,%esp
      ae:	89 4c 24 04          	mov    %ecx,0x4(%esp)
      b2:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
      b9:	e8 32 2e 00 00       	call   2ef0 <printf>
      be:	eb 12                	jmp    d2 <forktest+0x32>

  for(n=0; n<1000; n++){
    pid = fork();
    if(pid < 0)
      break;
    if(pid == 0)
      c0:	74 68                	je     12a <forktest+0x8a>
      c2:	43                   	inc    %ebx
      c3:	81 fb e8 03 00 00    	cmp    $0x3e8,%ebx
      c9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
      d0:	74 5d                	je     12f <forktest+0x8f>
      d2:	e8 ad 2c 00 00       	call   2d84 <fork>
      d7:	83 f8 00             	cmp    $0x0,%eax
      da:	7d e4                	jge    c0 <forktest+0x20>
      dc:	8d 74 26 00          	lea    0x0(%esi),%esi
      e0:	eb 0a                	jmp    ec <forktest+0x4c>
      exit();
  }
  
  if(n == 1000){
    printf(1, "fork claimed to work 1000 times!\n");
    exit();
  }
  
  for(; n > 0; n--){
    if(wait() < 0){
      e2:	e8 ad 2c 00 00       	call   2d94 <wait>
      e7:	85 c0                	test   %eax,%eax
      e9:	78 2a                	js     115 <forktest+0x75>
      eb:	4b                   	dec    %ebx
      ec:	85 db                	test   %ebx,%ebx
      ee:	89 f6                	mov    %esi,%esi
      f0:	7f f0                	jg     e2 <forktest+0x42>
      printf(1, "wait stopped early\n");
      exit();
    }
  }
  
  if(wait() != -1){
      f2:	e8 9d 2c 00 00       	call   2d94 <wait>
      f7:	40                   	inc    %eax
      f8:	75 4f                	jne    149 <forktest+0xa9>
    printf(1, "wait got too many\n");
    exit();
  }
  
  printf(1, "fork test OK\n");
      fa:	b8 6a 32 00 00       	mov    $0x326a,%eax
      ff:	89 44 24 04          	mov    %eax,0x4(%esp)
     103:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     10a:	e8 e1 2d 00 00       	call   2ef0 <printf>
}
     10f:	83 c4 14             	add    $0x14,%esp
     112:	5b                   	pop    %ebx
     113:	5d                   	pop    %ebp
     114:	c3                   	ret    
     115:	b8 43 32 00 00       	mov    $0x3243,%eax
     11a:	89 44 24 04          	mov    %eax,0x4(%esp)
     11e:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     125:	e8 c6 2d 00 00       	call   2ef0 <printf>
     12a:	e8 5d 2c 00 00       	call   2d8c <exit>
     12f:	ba c4 3e 00 00       	mov    $0x3ec4,%edx
     134:	89 54 24 04          	mov    %edx,0x4(%esp)
     138:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     13f:	e8 ac 2d 00 00       	call   2ef0 <printf>
     144:	e8 43 2c 00 00       	call   2d8c <exit>
     149:	b8 57 32 00 00       	mov    $0x3257,%eax
     14e:	89 44 24 04          	mov    %eax,0x4(%esp)
     152:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     159:	e8 92 2d 00 00       	call   2ef0 <printf>
     15e:	e8 29 2c 00 00       	call   2d8c <exit>
     163:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
     169:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00000170 <exitwait>:
     170:	55                   	push   %ebp
     171:	89 e5                	mov    %esp,%ebp
     173:	56                   	push   %esi
     174:	31 f6                	xor    %esi,%esi
     176:	53                   	push   %ebx
     177:	83 ec 10             	sub    $0x10,%esp
     17a:	eb 16                	jmp    192 <exitwait+0x22>
     17c:	8d 74 26 00          	lea    0x0(%esi),%esi
     180:	74 54                	je     1d6 <exitwait+0x66>
     182:	e8 0d 2c 00 00       	call   2d94 <wait>
     187:	39 c3                	cmp    %eax,%ebx
     189:	75 2f                	jne    1ba <exitwait+0x4a>
     18b:	46                   	inc    %esi
     18c:	83 fe 64             	cmp    $0x64,%esi
     18f:	90                   	nop    
     190:	74 49                	je     1db <exitwait+0x6b>
     192:	e8 ed 2b 00 00       	call   2d84 <fork>
     197:	83 f8 00             	cmp    $0x0,%eax
     19a:	89 c3                	mov    %eax,%ebx
     19c:	7d e2                	jge    180 <exitwait+0x10>
     19e:	b8 78 32 00 00       	mov    $0x3278,%eax
     1a3:	89 44 24 04          	mov    %eax,0x4(%esp)
     1a7:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     1ae:	e8 3d 2d 00 00       	call   2ef0 <printf>
     1b3:	83 c4 10             	add    $0x10,%esp
     1b6:	5b                   	pop    %ebx
     1b7:	5e                   	pop    %esi
     1b8:	5d                   	pop    %ebp
     1b9:	c3                   	ret    
     1ba:	be 85 32 00 00       	mov    $0x3285,%esi
     1bf:	89 74 24 04          	mov    %esi,0x4(%esp)
     1c3:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     1ca:	e8 21 2d 00 00       	call   2ef0 <printf>
     1cf:	83 c4 10             	add    $0x10,%esp
     1d2:	5b                   	pop    %ebx
     1d3:	5e                   	pop    %esi
     1d4:	5d                   	pop    %ebp
     1d5:	c3                   	ret    
     1d6:	e8 b1 2b 00 00       	call   2d8c <exit>
     1db:	bb 95 32 00 00       	mov    $0x3295,%ebx
     1e0:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     1e4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     1eb:	e8 00 2d 00 00       	call   2ef0 <printf>
     1f0:	83 c4 10             	add    $0x10,%esp
     1f3:	5b                   	pop    %ebx
     1f4:	5e                   	pop    %esi
     1f5:	5d                   	pop    %ebp
     1f6:	c3                   	ret    
     1f7:	89 f6                	mov    %esi,%esi
     1f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00000200 <fourteen>:
     200:	55                   	push   %ebp
     201:	b8 a2 32 00 00       	mov    $0x32a2,%eax
     206:	89 e5                	mov    %esp,%ebp
     208:	83 ec 08             	sub    $0x8,%esp
     20b:	89 44 24 04          	mov    %eax,0x4(%esp)
     20f:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     216:	e8 d5 2c 00 00       	call   2ef0 <printf>
     21b:	c7 04 24 dd 32 00 00 	movl   $0x32dd,(%esp)
     222:	e8 cd 2b 00 00       	call   2df4 <mkdir>
     227:	85 c0                	test   %eax,%eax
     229:	0f 85 9a 00 00 00    	jne    2c9 <fourteen+0xc9>
     22f:	c7 04 24 e8 3e 00 00 	movl   $0x3ee8,(%esp)
     236:	e8 b9 2b 00 00       	call   2df4 <mkdir>
     23b:	85 c0                	test   %eax,%eax
     23d:	0f 85 a0 00 00 00    	jne    2e3 <fourteen+0xe3>
     243:	b9 00 02 00 00       	mov    $0x200,%ecx
     248:	89 4c 24 04          	mov    %ecx,0x4(%esp)
     24c:	c7 04 24 38 3f 00 00 	movl   $0x3f38,(%esp)
     253:	e8 74 2b 00 00       	call   2dcc <open>
     258:	85 c0                	test   %eax,%eax
     25a:	0f 88 9d 00 00 00    	js     2fd <fourteen+0xfd>
     260:	89 04 24             	mov    %eax,(%esp)
     263:	e8 4c 2b 00 00       	call   2db4 <close>
     268:	31 c0                	xor    %eax,%eax
     26a:	89 44 24 04          	mov    %eax,0x4(%esp)
     26e:	c7 04 24 a8 3f 00 00 	movl   $0x3fa8,(%esp)
     275:	e8 52 2b 00 00       	call   2dcc <open>
     27a:	85 c0                	test   %eax,%eax
     27c:	0f 88 95 00 00 00    	js     317 <fourteen+0x117>
     282:	89 04 24             	mov    %eax,(%esp)
     285:	e8 2a 2b 00 00       	call   2db4 <close>
     28a:	c7 04 24 ce 32 00 00 	movl   $0x32ce,(%esp)
     291:	e8 5e 2b 00 00       	call   2df4 <mkdir>
     296:	85 c0                	test   %eax,%eax
     298:	0f 84 93 00 00 00    	je     331 <fourteen+0x131>
     29e:	c7 04 24 44 40 00 00 	movl   $0x4044,(%esp)
     2a5:	e8 4a 2b 00 00       	call   2df4 <mkdir>
     2aa:	85 c0                	test   %eax,%eax
     2ac:	0f 84 99 00 00 00    	je     34b <fourteen+0x14b>
     2b2:	b8 ec 32 00 00       	mov    $0x32ec,%eax
     2b7:	89 44 24 04          	mov    %eax,0x4(%esp)
     2bb:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     2c2:	e8 29 2c 00 00       	call   2ef0 <printf>
     2c7:	c9                   	leave  
     2c8:	c3                   	ret    
     2c9:	b8 b1 32 00 00       	mov    $0x32b1,%eax
     2ce:	89 44 24 04          	mov    %eax,0x4(%esp)
     2d2:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     2d9:	e8 12 2c 00 00       	call   2ef0 <printf>
     2de:	e8 a9 2a 00 00       	call   2d8c <exit>
     2e3:	b8 08 3f 00 00       	mov    $0x3f08,%eax
     2e8:	89 44 24 04          	mov    %eax,0x4(%esp)
     2ec:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     2f3:	e8 f8 2b 00 00       	call   2ef0 <printf>
     2f8:	e8 8f 2a 00 00       	call   2d8c <exit>
     2fd:	ba 68 3f 00 00       	mov    $0x3f68,%edx
     302:	89 54 24 04          	mov    %edx,0x4(%esp)
     306:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     30d:	e8 de 2b 00 00       	call   2ef0 <printf>
     312:	e8 75 2a 00 00       	call   2d8c <exit>
     317:	b8 d8 3f 00 00       	mov    $0x3fd8,%eax
     31c:	89 44 24 04          	mov    %eax,0x4(%esp)
     320:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     327:	e8 c4 2b 00 00       	call   2ef0 <printf>
     32c:	e8 5b 2a 00 00       	call   2d8c <exit>
     331:	b8 14 40 00 00       	mov    $0x4014,%eax
     336:	89 44 24 04          	mov    %eax,0x4(%esp)
     33a:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     341:	e8 aa 2b 00 00       	call   2ef0 <printf>
     346:	e8 41 2a 00 00       	call   2d8c <exit>
     34b:	b8 64 40 00 00       	mov    $0x4064,%eax
     350:	89 44 24 04          	mov    %eax,0x4(%esp)
     354:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     35b:	e8 90 2b 00 00       	call   2ef0 <printf>
     360:	e8 27 2a 00 00       	call   2d8c <exit>
     365:	8d 74 26 00          	lea    0x0(%esi),%esi
     369:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00000370 <iref>:
     370:	55                   	push   %ebp
     371:	b8 f9 32 00 00       	mov    $0x32f9,%eax
     376:	89 e5                	mov    %esp,%ebp
     378:	53                   	push   %ebx
     379:	31 db                	xor    %ebx,%ebx
     37b:	83 ec 14             	sub    $0x14,%esp
     37e:	89 44 24 04          	mov    %eax,0x4(%esp)
     382:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     389:	e8 62 2b 00 00       	call   2ef0 <printf>
     38e:	89 f6                	mov    %esi,%esi
     390:	c7 04 24 0a 33 00 00 	movl   $0x330a,(%esp)
     397:	e8 58 2a 00 00       	call   2df4 <mkdir>
     39c:	85 c0                	test   %eax,%eax
     39e:	0f 85 b4 00 00 00    	jne    458 <iref+0xe8>
     3a4:	c7 04 24 0a 33 00 00 	movl   $0x330a,(%esp)
     3ab:	e8 4c 2a 00 00       	call   2dfc <chdir>
     3b0:	85 c0                	test   %eax,%eax
     3b2:	0f 85 ba 00 00 00    	jne    472 <iref+0x102>
     3b8:	c7 04 24 bb 3d 00 00 	movl   $0x3dbb,(%esp)
     3bf:	e8 30 2a 00 00       	call   2df4 <mkdir>
     3c4:	ba bb 3d 00 00       	mov    $0x3dbb,%edx
     3c9:	89 54 24 04          	mov    %edx,0x4(%esp)
     3cd:	c7 04 24 38 33 00 00 	movl   $0x3338,(%esp)
     3d4:	e8 13 2a 00 00       	call   2dec <link>
     3d9:	b8 00 02 00 00       	mov    $0x200,%eax
     3de:	89 44 24 04          	mov    %eax,0x4(%esp)
     3e2:	c7 04 24 bb 3d 00 00 	movl   $0x3dbb,(%esp)
     3e9:	e8 de 29 00 00       	call   2dcc <open>
     3ee:	85 c0                	test   %eax,%eax
     3f0:	78 08                	js     3fa <iref+0x8a>
     3f2:	89 04 24             	mov    %eax,(%esp)
     3f5:	e8 ba 29 00 00       	call   2db4 <close>
     3fa:	b8 00 02 00 00       	mov    $0x200,%eax
     3ff:	89 44 24 04          	mov    %eax,0x4(%esp)
     403:	c7 04 24 aa 38 00 00 	movl   $0x38aa,(%esp)
     40a:	e8 bd 29 00 00       	call   2dcc <open>
     40f:	85 c0                	test   %eax,%eax
     411:	78 08                	js     41b <iref+0xab>
     413:	89 04 24             	mov    %eax,(%esp)
     416:	e8 99 29 00 00       	call   2db4 <close>
     41b:	43                   	inc    %ebx
     41c:	c7 04 24 aa 38 00 00 	movl   $0x38aa,(%esp)
     423:	e8 b4 29 00 00       	call   2ddc <unlink>
     428:	83 fb 33             	cmp    $0x33,%ebx
     42b:	0f 85 5f ff ff ff    	jne    390 <iref+0x20>
     431:	c7 04 24 3f 33 00 00 	movl   $0x333f,(%esp)
     438:	e8 bf 29 00 00       	call   2dfc <chdir>
     43d:	b8 41 33 00 00       	mov    $0x3341,%eax
     442:	89 44 24 04          	mov    %eax,0x4(%esp)
     446:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     44d:	e8 9e 2a 00 00       	call   2ef0 <printf>
     452:	83 c4 14             	add    $0x14,%esp
     455:	5b                   	pop    %ebx
     456:	5d                   	pop    %ebp
     457:	c3                   	ret    
     458:	bb 10 33 00 00       	mov    $0x3310,%ebx
     45d:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     461:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     468:	e8 83 2a 00 00       	call   2ef0 <printf>
     46d:	e8 1a 29 00 00       	call   2d8c <exit>
     472:	b9 24 33 00 00       	mov    $0x3324,%ecx
     477:	89 4c 24 04          	mov    %ecx,0x4(%esp)
     47b:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     482:	e8 69 2a 00 00       	call   2ef0 <printf>
     487:	e8 00 29 00 00       	call   2d8c <exit>
     48c:	8d 74 26 00          	lea    0x0(%esi),%esi

00000490 <rmdot>:
     490:	55                   	push   %ebp
     491:	b8 55 33 00 00       	mov    $0x3355,%eax
     496:	89 e5                	mov    %esp,%ebp
     498:	83 ec 08             	sub    $0x8,%esp
     49b:	89 44 24 04          	mov    %eax,0x4(%esp)
     49f:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     4a6:	e8 45 2a 00 00       	call   2ef0 <printf>
     4ab:	c7 04 24 61 33 00 00 	movl   $0x3361,(%esp)
     4b2:	e8 3d 29 00 00       	call   2df4 <mkdir>
     4b7:	85 c0                	test   %eax,%eax
     4b9:	0f 85 a3 00 00 00    	jne    562 <rmdot+0xd2>
     4bf:	c7 04 24 61 33 00 00 	movl   $0x3361,(%esp)
     4c6:	e8 31 29 00 00       	call   2dfc <chdir>
     4cb:	85 c0                	test   %eax,%eax
     4cd:	0f 85 a9 00 00 00    	jne    57c <rmdot+0xec>
     4d3:	c7 04 24 c8 37 00 00 	movl   $0x37c8,(%esp)
     4da:	e8 fd 28 00 00       	call   2ddc <unlink>
     4df:	85 c0                	test   %eax,%eax
     4e1:	0f 84 af 00 00 00    	je     596 <rmdot+0x106>
     4e7:	c7 04 24 c7 37 00 00 	movl   $0x37c7,(%esp)
     4ee:	e8 e9 28 00 00       	call   2ddc <unlink>
     4f3:	85 c0                	test   %eax,%eax
     4f5:	0f 84 b5 00 00 00    	je     5b0 <rmdot+0x120>
     4fb:	c7 04 24 3f 33 00 00 	movl   $0x333f,(%esp)
     502:	e8 f5 28 00 00       	call   2dfc <chdir>
     507:	85 c0                	test   %eax,%eax
     509:	0f 85 bb 00 00 00    	jne    5ca <rmdot+0x13a>
     50f:	c7 04 24 b9 33 00 00 	movl   $0x33b9,(%esp)
     516:	e8 c1 28 00 00       	call   2ddc <unlink>
     51b:	85 c0                	test   %eax,%eax
     51d:	0f 84 c1 00 00 00    	je     5e4 <rmdot+0x154>
     523:	c7 04 24 d7 33 00 00 	movl   $0x33d7,(%esp)
     52a:	e8 ad 28 00 00       	call   2ddc <unlink>
     52f:	85 c0                	test   %eax,%eax
     531:	0f 84 c7 00 00 00    	je     5fe <rmdot+0x16e>
     537:	c7 04 24 61 33 00 00 	movl   $0x3361,(%esp)
     53e:	e8 99 28 00 00       	call   2ddc <unlink>
     543:	85 c0                	test   %eax,%eax
     545:	0f 85 cd 00 00 00    	jne    618 <rmdot+0x188>
     54b:	b8 0c 34 00 00       	mov    $0x340c,%eax
     550:	89 44 24 04          	mov    %eax,0x4(%esp)
     554:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     55b:	e8 90 29 00 00       	call   2ef0 <printf>
     560:	c9                   	leave  
     561:	c3                   	ret    
     562:	b8 66 33 00 00       	mov    $0x3366,%eax
     567:	89 44 24 04          	mov    %eax,0x4(%esp)
     56b:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     572:	e8 79 29 00 00       	call   2ef0 <printf>
     577:	e8 10 28 00 00       	call   2d8c <exit>
     57c:	b8 79 33 00 00       	mov    $0x3379,%eax
     581:	89 44 24 04          	mov    %eax,0x4(%esp)
     585:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     58c:	e8 5f 29 00 00       	call   2ef0 <printf>
     591:	e8 f6 27 00 00       	call   2d8c <exit>
     596:	b9 8c 33 00 00       	mov    $0x338c,%ecx
     59b:	89 4c 24 04          	mov    %ecx,0x4(%esp)
     59f:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     5a6:	e8 45 29 00 00       	call   2ef0 <printf>
     5ab:	e8 dc 27 00 00       	call   2d8c <exit>
     5b0:	ba 9a 33 00 00       	mov    $0x339a,%edx
     5b5:	89 54 24 04          	mov    %edx,0x4(%esp)
     5b9:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     5c0:	e8 2b 29 00 00       	call   2ef0 <printf>
     5c5:	e8 c2 27 00 00       	call   2d8c <exit>
     5ca:	b8 a9 33 00 00       	mov    $0x33a9,%eax
     5cf:	89 44 24 04          	mov    %eax,0x4(%esp)
     5d3:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     5da:	e8 11 29 00 00       	call   2ef0 <printf>
     5df:	e8 a8 27 00 00       	call   2d8c <exit>
     5e4:	b8 c0 33 00 00       	mov    $0x33c0,%eax
     5e9:	89 44 24 04          	mov    %eax,0x4(%esp)
     5ed:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     5f4:	e8 f7 28 00 00       	call   2ef0 <printf>
     5f9:	e8 8e 27 00 00       	call   2d8c <exit>
     5fe:	b8 df 33 00 00       	mov    $0x33df,%eax
     603:	89 44 24 04          	mov    %eax,0x4(%esp)
     607:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     60e:	e8 dd 28 00 00       	call   2ef0 <printf>
     613:	e8 74 27 00 00       	call   2d8c <exit>
     618:	b8 f7 33 00 00       	mov    $0x33f7,%eax
     61d:	89 44 24 04          	mov    %eax,0x4(%esp)
     621:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     628:	e8 c3 28 00 00       	call   2ef0 <printf>
     62d:	e8 5a 27 00 00       	call   2d8c <exit>
     632:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
     639:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00000640 <bigdir>:
     640:	55                   	push   %ebp
     641:	89 e5                	mov    %esp,%ebp
     643:	56                   	push   %esi
     644:	53                   	push   %ebx
     645:	bb 16 34 00 00       	mov    $0x3416,%ebx
     64a:	83 ec 20             	sub    $0x20,%esp
     64d:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     651:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     658:	e8 93 28 00 00       	call   2ef0 <printf>
     65d:	c7 04 24 23 34 00 00 	movl   $0x3423,(%esp)
     664:	e8 73 27 00 00       	call   2ddc <unlink>
     669:	b9 00 02 00 00       	mov    $0x200,%ecx
     66e:	89 4c 24 04          	mov    %ecx,0x4(%esp)
     672:	c7 04 24 23 34 00 00 	movl   $0x3423,(%esp)
     679:	e8 4e 27 00 00       	call   2dcc <open>
     67e:	85 c0                	test   %eax,%eax
     680:	0f 88 f1 00 00 00    	js     777 <bigdir+0x137>
     686:	89 04 24             	mov    %eax,(%esp)
     689:	31 db                	xor    %ebx,%ebx
     68b:	e8 24 27 00 00       	call   2db4 <close>
     690:	8d 75 ee             	lea    0xffffffee(%ebp),%esi
     693:	eb 09                	jmp    69e <bigdir+0x5e>
     695:	43                   	inc    %ebx
     696:	81 fb f4 01 00 00    	cmp    $0x1f4,%ebx
     69c:	74 56                	je     6f4 <bigdir+0xb4>
     69e:	89 d9                	mov    %ebx,%ecx
     6a0:	c1 f9 1f             	sar    $0x1f,%ecx
     6a3:	c1 e9 1a             	shr    $0x1a,%ecx
     6a6:	8d 04 19             	lea    (%ecx,%ebx,1),%eax
     6a9:	89 c2                	mov    %eax,%edx
     6ab:	83 e0 3f             	and    $0x3f,%eax
     6ae:	29 c8                	sub    %ecx,%eax
     6b0:	c1 fa 06             	sar    $0x6,%edx
     6b3:	04 30                	add    $0x30,%al
     6b5:	80 c2 30             	add    $0x30,%dl
     6b8:	c6 45 ee 78          	movb   $0x78,0xffffffee(%ebp)
     6bc:	88 55 ef             	mov    %dl,0xffffffef(%ebp)
     6bf:	88 45 f0             	mov    %al,0xfffffff0(%ebp)
     6c2:	c6 45 f1 00          	movb   $0x0,0xfffffff1(%ebp)
     6c6:	89 74 24 04          	mov    %esi,0x4(%esp)
     6ca:	c7 04 24 23 34 00 00 	movl   $0x3423,(%esp)
     6d1:	e8 16 27 00 00       	call   2dec <link>
     6d6:	85 c0                	test   %eax,%eax
     6d8:	74 bb                	je     695 <bigdir+0x55>
     6da:	b8 3c 34 00 00       	mov    $0x343c,%eax
     6df:	89 44 24 04          	mov    %eax,0x4(%esp)
     6e3:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     6ea:	e8 01 28 00 00       	call   2ef0 <printf>
     6ef:	e8 98 26 00 00       	call   2d8c <exit>
     6f4:	c7 04 24 23 34 00 00 	movl   $0x3423,(%esp)
     6fb:	31 db                	xor    %ebx,%ebx
     6fd:	e8 da 26 00 00       	call   2ddc <unlink>
     702:	eb 09                	jmp    70d <bigdir+0xcd>
     704:	43                   	inc    %ebx
     705:	81 fb f4 01 00 00    	cmp    $0x1f4,%ebx
     70b:	74 4e                	je     75b <bigdir+0x11b>
     70d:	89 d9                	mov    %ebx,%ecx
     70f:	c1 f9 1f             	sar    $0x1f,%ecx
     712:	c1 e9 1a             	shr    $0x1a,%ecx
     715:	8d 04 19             	lea    (%ecx,%ebx,1),%eax
     718:	89 c2                	mov    %eax,%edx
     71a:	83 e0 3f             	and    $0x3f,%eax
     71d:	29 c8                	sub    %ecx,%eax
     71f:	c1 fa 06             	sar    $0x6,%edx
     722:	04 30                	add    $0x30,%al
     724:	80 c2 30             	add    $0x30,%dl
     727:	c6 45 ee 78          	movb   $0x78,0xffffffee(%ebp)
     72b:	88 55 ef             	mov    %dl,0xffffffef(%ebp)
     72e:	88 45 f0             	mov    %al,0xfffffff0(%ebp)
     731:	c6 45 f1 00          	movb   $0x0,0xfffffff1(%ebp)
     735:	89 34 24             	mov    %esi,(%esp)
     738:	e8 9f 26 00 00       	call   2ddc <unlink>
     73d:	85 c0                	test   %eax,%eax
     73f:	74 c3                	je     704 <bigdir+0xc4>
     741:	b8 50 34 00 00       	mov    $0x3450,%eax
     746:	89 44 24 04          	mov    %eax,0x4(%esp)
     74a:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     751:	e8 9a 27 00 00       	call   2ef0 <printf>
     756:	e8 31 26 00 00       	call   2d8c <exit>
     75b:	b8 65 34 00 00       	mov    $0x3465,%eax
     760:	89 44 24 04          	mov    %eax,0x4(%esp)
     764:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     76b:	e8 80 27 00 00       	call   2ef0 <printf>
     770:	83 c4 20             	add    $0x20,%esp
     773:	5b                   	pop    %ebx
     774:	5e                   	pop    %esi
     775:	5d                   	pop    %ebp
     776:	c3                   	ret    
     777:	ba 26 34 00 00       	mov    $0x3426,%edx
     77c:	89 54 24 04          	mov    %edx,0x4(%esp)
     780:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     787:	e8 64 27 00 00       	call   2ef0 <printf>
     78c:	e8 fb 25 00 00       	call   2d8c <exit>
     791:	eb 0d                	jmp    7a0 <createdelete>
     793:	90                   	nop    
     794:	90                   	nop    
     795:	90                   	nop    
     796:	90                   	nop    
     797:	90                   	nop    
     798:	90                   	nop    
     799:	90                   	nop    
     79a:	90                   	nop    
     79b:	90                   	nop    
     79c:	90                   	nop    
     79d:	90                   	nop    
     79e:	90                   	nop    
     79f:	90                   	nop    

000007a0 <createdelete>:
     7a0:	55                   	push   %ebp
     7a1:	89 e5                	mov    %esp,%ebp
     7a3:	57                   	push   %edi
     7a4:	56                   	push   %esi
     7a5:	53                   	push   %ebx
     7a6:	bb 70 34 00 00       	mov    $0x3470,%ebx
     7ab:	83 ec 3c             	sub    $0x3c,%esp
     7ae:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     7b2:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     7b9:	e8 32 27 00 00       	call   2ef0 <printf>
     7be:	e8 c1 25 00 00       	call   2d84 <fork>
     7c3:	83 f8 00             	cmp    $0x0,%eax
     7c6:	89 c7                	mov    %eax,%edi
     7c8:	0f 8c 31 02 00 00    	jl     9ff <createdelete+0x25f>
     7ce:	83 f8 01             	cmp    $0x1,%eax
     7d1:	19 c0                	sbb    %eax,%eax
     7d3:	31 db                	xor    %ebx,%ebx
     7d5:	24 f3                	and    $0xf3,%al
     7d7:	04 70                	add    $0x70,%al
     7d9:	88 45 d4             	mov    %al,0xffffffd4(%ebp)
     7dc:	8d 75 d4             	lea    0xffffffd4(%ebp),%esi
     7df:	c6 45 d6 00          	movb   $0x0,0xffffffd6(%ebp)
     7e3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
     7e9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi
     7f0:	88 d8                	mov    %bl,%al
     7f2:	ba 02 02 00 00       	mov    $0x202,%edx
     7f7:	04 30                	add    $0x30,%al
     7f9:	88 45 d5             	mov    %al,0xffffffd5(%ebp)
     7fc:	89 54 24 04          	mov    %edx,0x4(%esp)
     800:	89 34 24             	mov    %esi,(%esp)
     803:	e8 c4 25 00 00       	call   2dcc <open>
     808:	85 c0                	test   %eax,%eax
     80a:	0f 88 b7 01 00 00    	js     9c7 <createdelete+0x227>
     810:	89 04 24             	mov    %eax,(%esp)
     813:	e8 9c 25 00 00       	call   2db4 <close>
     818:	85 db                	test   %ebx,%ebx
     81a:	0f 84 30 01 00 00    	je     950 <createdelete+0x1b0>
     820:	f6 c3 01             	test   $0x1,%bl
     823:	0f 84 37 01 00 00    	je     960 <createdelete+0x1c0>
     829:	43                   	inc    %ebx
     82a:	83 fb 13             	cmp    $0x13,%ebx
     82d:	8d 76 00             	lea    0x0(%esi),%esi
     830:	7e be                	jle    7f0 <createdelete+0x50>
     832:	85 ff                	test   %edi,%edi
     834:	0f 84 c0 01 00 00    	je     9fa <createdelete+0x25a>
     83a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
     840:	e8 4f 25 00 00       	call   2d94 <wait>
     845:	31 db                	xor    %ebx,%ebx
     847:	88 d8                	mov    %bl,%al
     849:	04 30                	add    $0x30,%al
     84b:	88 45 d3             	mov    %al,0xffffffd3(%ebp)
     84e:	88 45 d5             	mov    %al,0xffffffd5(%ebp)
     851:	31 c0                	xor    %eax,%eax
     853:	c6 45 d4 70          	movb   $0x70,0xffffffd4(%ebp)
     857:	89 44 24 04          	mov    %eax,0x4(%esp)
     85b:	89 34 24             	mov    %esi,(%esp)
     85e:	e8 69 25 00 00       	call   2dcc <open>
     863:	85 db                	test   %ebx,%ebx
     865:	0f 94 c2             	sete   %dl
     868:	83 fb 09             	cmp    $0x9,%ebx
     86b:	89 c1                	mov    %eax,%ecx
     86d:	0f 9f c0             	setg   %al
     870:	08 c2                	or     %al,%dl
     872:	88 55 d1             	mov    %dl,0xffffffd1(%ebp)
     875:	74 08                	je     87f <createdelete+0xdf>
     877:	85 c9                	test   %ecx,%ecx
     879:	0f 88 62 01 00 00    	js     9e1 <createdelete+0x241>
     87f:	8d 43 ff             	lea    0xffffffff(%ebx),%eax
     882:	83 f8 08             	cmp    $0x8,%eax
     885:	89 c8                	mov    %ecx,%eax
     887:	0f 96 45 d2          	setbe  0xffffffd2(%ebp)
     88b:	f7 d0                	not    %eax
     88d:	c1 e8 1f             	shr    $0x1f,%eax
     890:	80 7d d2 00          	cmpb   $0x0,0xffffffd2(%ebp)
     894:	0f 84 f9 00 00 00    	je     993 <createdelete+0x1f3>
     89a:	84 c0                	test   %al,%al
     89c:	0f 85 8e 00 00 00    	jne    930 <createdelete+0x190>
     8a2:	0f b6 45 d3          	movzbl 0xffffffd3(%ebp),%eax
     8a6:	c6 45 d4 63          	movb   $0x63,0xffffffd4(%ebp)
     8aa:	89 34 24             	mov    %esi,(%esp)
     8ad:	88 45 d5             	mov    %al,0xffffffd5(%ebp)
     8b0:	31 c0                	xor    %eax,%eax
     8b2:	89 44 24 04          	mov    %eax,0x4(%esp)
     8b6:	e8 11 25 00 00       	call   2dcc <open>
     8bb:	80 7d d1 00          	cmpb   $0x0,0xffffffd1(%ebp)
     8bf:	89 c2                	mov    %eax,%edx
     8c1:	74 08                	je     8cb <createdelete+0x12b>
     8c3:	85 c0                	test   %eax,%eax
     8c5:	0f 88 16 01 00 00    	js     9e1 <createdelete+0x241>
     8cb:	89 d0                	mov    %edx,%eax
     8cd:	f7 d0                	not    %eax
     8cf:	c1 e8 1f             	shr    $0x1f,%eax
     8d2:	80 7d d2 00          	cmpb   $0x0,0xffffffd2(%ebp)
     8d6:	0f 84 cc 00 00 00    	je     9a8 <createdelete+0x208>
     8dc:	84 c0                	test   %al,%al
     8de:	75 50                	jne    930 <createdelete+0x190>
     8e0:	43                   	inc    %ebx
     8e1:	83 fb 14             	cmp    $0x14,%ebx
     8e4:	0f 85 5d ff ff ff    	jne    847 <createdelete+0xa7>
     8ea:	b3 30                	mov    $0x30,%bl
     8ec:	88 5d d5             	mov    %bl,0xffffffd5(%ebp)
     8ef:	fe c3                	inc    %bl
     8f1:	c6 45 d4 70          	movb   $0x70,0xffffffd4(%ebp)
     8f5:	89 34 24             	mov    %esi,(%esp)
     8f8:	e8 df 24 00 00       	call   2ddc <unlink>
     8fd:	c6 45 d4 63          	movb   $0x63,0xffffffd4(%ebp)
     901:	89 34 24             	mov    %esi,(%esp)
     904:	e8 d3 24 00 00       	call   2ddc <unlink>
     909:	80 fb 44             	cmp    $0x44,%bl
     90c:	75 de                	jne    8ec <createdelete+0x14c>
     90e:	be 92 34 00 00       	mov    $0x3492,%esi
     913:	89 74 24 04          	mov    %esi,0x4(%esp)
     917:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     91e:	e8 cd 25 00 00       	call   2ef0 <printf>
     923:	83 c4 3c             	add    $0x3c,%esp
     926:	5b                   	pop    %ebx
     927:	5e                   	pop    %esi
     928:	5f                   	pop    %edi
     929:	5d                   	pop    %ebp
     92a:	c3                   	ret    
     92b:	90                   	nop    
     92c:	8d 74 26 00          	lea    0x0(%esi),%esi
     930:	bf bc 40 00 00       	mov    $0x40bc,%edi
     935:	89 74 24 08          	mov    %esi,0x8(%esp)
     939:	89 7c 24 04          	mov    %edi,0x4(%esp)
     93d:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     944:	e8 a7 25 00 00       	call   2ef0 <printf>
     949:	e8 3e 24 00 00       	call   2d8c <exit>
     94e:	89 f6                	mov    %esi,%esi
     950:	bb 01 00 00 00       	mov    $0x1,%ebx
     955:	e9 96 fe ff ff       	jmp    7f0 <createdelete+0x50>
     95a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
     960:	89 d8                	mov    %ebx,%eax
     962:	d1 f8                	sar    %eax
     964:	04 30                	add    $0x30,%al
     966:	88 45 d5             	mov    %al,0xffffffd5(%ebp)
     969:	89 34 24             	mov    %esi,(%esp)
     96c:	e8 6b 24 00 00       	call   2ddc <unlink>
     971:	85 c0                	test   %eax,%eax
     973:	0f 89 b0 fe ff ff    	jns    829 <createdelete+0x89>
     979:	b8 83 34 00 00       	mov    $0x3483,%eax
     97e:	89 44 24 04          	mov    %eax,0x4(%esp)
     982:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     989:	e8 62 25 00 00       	call   2ef0 <printf>
     98e:	e8 f9 23 00 00       	call   2d8c <exit>
     993:	84 c0                	test   %al,%al
     995:	0f 84 07 ff ff ff    	je     8a2 <createdelete+0x102>
     99b:	89 0c 24             	mov    %ecx,(%esp)
     99e:	e8 11 24 00 00       	call   2db4 <close>
     9a3:	e9 fa fe ff ff       	jmp    8a2 <createdelete+0x102>
     9a8:	84 c0                	test   %al,%al
     9aa:	0f 84 30 ff ff ff    	je     8e0 <createdelete+0x140>
     9b0:	43                   	inc    %ebx
     9b1:	89 14 24             	mov    %edx,(%esp)
     9b4:	e8 fb 23 00 00       	call   2db4 <close>
     9b9:	83 fb 14             	cmp    $0x14,%ebx
     9bc:	0f 85 85 fe ff ff    	jne    847 <createdelete+0xa7>
     9c2:	e9 23 ff ff ff       	jmp    8ea <createdelete+0x14a>
     9c7:	b8 2d 34 00 00       	mov    $0x342d,%eax
     9cc:	89 44 24 04          	mov    %eax,0x4(%esp)
     9d0:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     9d7:	e8 14 25 00 00       	call   2ef0 <printf>
     9dc:	e8 ab 23 00 00       	call   2d8c <exit>
     9e1:	b8 98 40 00 00       	mov    $0x4098,%eax
     9e6:	89 74 24 08          	mov    %esi,0x8(%esp)
     9ea:	89 44 24 04          	mov    %eax,0x4(%esp)
     9ee:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     9f5:	e8 f6 24 00 00       	call   2ef0 <printf>
     9fa:	e8 8d 23 00 00       	call   2d8c <exit>
     9ff:	b9 78 32 00 00       	mov    $0x3278,%ecx
     a04:	89 4c 24 04          	mov    %ecx,0x4(%esp)
     a08:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     a0f:	e8 dc 24 00 00       	call   2ef0 <printf>
     a14:	e8 73 23 00 00       	call   2d8c <exit>
     a19:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00000a20 <dirtest>:
     a20:	55                   	push   %ebp
     a21:	b8 a3 34 00 00       	mov    $0x34a3,%eax
     a26:	89 e5                	mov    %esp,%ebp
     a28:	83 ec 08             	sub    $0x8,%esp
     a2b:	89 44 24 04          	mov    %eax,0x4(%esp)
     a2f:	a1 54 44 00 00       	mov    0x4454,%eax
     a34:	89 04 24             	mov    %eax,(%esp)
     a37:	e8 b4 24 00 00       	call   2ef0 <printf>
     a3c:	c7 04 24 af 34 00 00 	movl   $0x34af,(%esp)
     a43:	e8 ac 23 00 00       	call   2df4 <mkdir>
     a48:	85 c0                	test   %eax,%eax
     a4a:	78 48                	js     a94 <dirtest+0x74>
     a4c:	c7 04 24 af 34 00 00 	movl   $0x34af,(%esp)
     a53:	e8 a4 23 00 00       	call   2dfc <chdir>
     a58:	85 c0                	test   %eax,%eax
     a5a:	78 53                	js     aaf <dirtest+0x8f>
     a5c:	c7 04 24 c7 37 00 00 	movl   $0x37c7,(%esp)
     a63:	e8 94 23 00 00       	call   2dfc <chdir>
     a68:	85 c0                	test   %eax,%eax
     a6a:	78 4a                	js     ab6 <dirtest+0x96>
     a6c:	c7 04 24 af 34 00 00 	movl   $0x34af,(%esp)
     a73:	e8 64 23 00 00       	call   2ddc <unlink>
     a78:	85 c0                	test   %eax,%eax
     a7a:	78 41                	js     abd <dirtest+0x9d>
     a7c:	b8 a3 34 00 00       	mov    $0x34a3,%eax
     a81:	89 44 24 04          	mov    %eax,0x4(%esp)
     a85:	a1 54 44 00 00       	mov    0x4454,%eax
     a8a:	89 04 24             	mov    %eax,(%esp)
     a8d:	e8 5e 24 00 00       	call   2ef0 <printf>
     a92:	c9                   	leave  
     a93:	c3                   	ret    
     a94:	b8 b4 34 00 00       	mov    $0x34b4,%eax
     a99:	89 44 24 04          	mov    %eax,0x4(%esp)
     a9d:	a1 54 44 00 00       	mov    0x4454,%eax
     aa2:	89 04 24             	mov    %eax,(%esp)
     aa5:	e8 46 24 00 00       	call   2ef0 <printf>
     aaa:	e8 dd 22 00 00       	call   2d8c <exit>
     aaf:	b8 c2 34 00 00       	mov    $0x34c2,%eax
     ab4:	eb e3                	jmp    a99 <dirtest+0x79>
     ab6:	b8 d5 34 00 00       	mov    $0x34d5,%eax
     abb:	eb dc                	jmp    a99 <dirtest+0x79>
     abd:	b8 e6 34 00 00       	mov    $0x34e6,%eax
     ac2:	eb d5                	jmp    a99 <dirtest+0x79>
     ac4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
     aca:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

00000ad0 <createtest>:
     ad0:	55                   	push   %ebp
     ad1:	89 e5                	mov    %esp,%ebp
     ad3:	53                   	push   %ebx
     ad4:	bb dc 40 00 00       	mov    $0x40dc,%ebx
     ad9:	83 ec 14             	sub    $0x14,%esp
     adc:	a1 54 44 00 00       	mov    0x4454,%eax
     ae1:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     ae5:	b3 30                	mov    $0x30,%bl
     ae7:	89 04 24             	mov    %eax,(%esp)
     aea:	e8 01 24 00 00       	call   2ef0 <printf>
     aef:	c6 05 80 4c 00 00 61 	movb   $0x61,0x4c80
     af6:	c6 05 82 4c 00 00 00 	movb   $0x0,0x4c82
     afd:	8d 76 00             	lea    0x0(%esi),%esi
     b00:	b9 02 02 00 00       	mov    $0x202,%ecx
     b05:	88 1d 81 4c 00 00    	mov    %bl,0x4c81
     b0b:	fe c3                	inc    %bl
     b0d:	89 4c 24 04          	mov    %ecx,0x4(%esp)
     b11:	c7 04 24 80 4c 00 00 	movl   $0x4c80,(%esp)
     b18:	e8 af 22 00 00       	call   2dcc <open>
     b1d:	89 04 24             	mov    %eax,(%esp)
     b20:	e8 8f 22 00 00       	call   2db4 <close>
     b25:	80 fb 64             	cmp    $0x64,%bl
     b28:	75 d6                	jne    b00 <createtest+0x30>
     b2a:	c6 05 80 4c 00 00 61 	movb   $0x61,0x4c80
     b31:	b3 30                	mov    $0x30,%bl
     b33:	c6 05 82 4c 00 00 00 	movb   $0x0,0x4c82
     b3a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
     b40:	88 1d 81 4c 00 00    	mov    %bl,0x4c81
     b46:	fe c3                	inc    %bl
     b48:	c7 04 24 80 4c 00 00 	movl   $0x4c80,(%esp)
     b4f:	e8 88 22 00 00       	call   2ddc <unlink>
     b54:	80 fb 64             	cmp    $0x64,%bl
     b57:	75 e7                	jne    b40 <createtest+0x70>
     b59:	a1 54 44 00 00       	mov    0x4454,%eax
     b5e:	ba 04 41 00 00       	mov    $0x4104,%edx
     b63:	89 54 24 04          	mov    %edx,0x4(%esp)
     b67:	89 04 24             	mov    %eax,(%esp)
     b6a:	e8 81 23 00 00       	call   2ef0 <printf>
     b6f:	83 c4 14             	add    $0x14,%esp
     b72:	5b                   	pop    %ebx
     b73:	5d                   	pop    %ebp
     b74:	c3                   	ret    
     b75:	8d 74 26 00          	lea    0x0(%esi),%esi
     b79:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00000b80 <dirfile>:
     b80:	55                   	push   %ebp
     b81:	b8 fa 34 00 00       	mov    $0x34fa,%eax
     b86:	89 e5                	mov    %esp,%ebp
     b88:	53                   	push   %ebx
     b89:	bb 00 02 00 00       	mov    $0x200,%ebx
     b8e:	83 ec 14             	sub    $0x14,%esp
     b91:	89 44 24 04          	mov    %eax,0x4(%esp)
     b95:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     b9c:	e8 4f 23 00 00       	call   2ef0 <printf>
     ba1:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     ba5:	c7 04 24 07 35 00 00 	movl   $0x3507,(%esp)
     bac:	e8 1b 22 00 00       	call   2dcc <open>
     bb1:	85 c0                	test   %eax,%eax
     bb3:	0f 88 3c 01 00 00    	js     cf5 <dirfile+0x175>
     bb9:	89 04 24             	mov    %eax,(%esp)
     bbc:	e8 f3 21 00 00       	call   2db4 <close>
     bc1:	c7 04 24 07 35 00 00 	movl   $0x3507,(%esp)
     bc8:	e8 2f 22 00 00       	call   2dfc <chdir>
     bcd:	85 c0                	test   %eax,%eax
     bcf:	0f 84 3a 01 00 00    	je     d0f <dirfile+0x18f>
     bd5:	31 c0                	xor    %eax,%eax
     bd7:	89 44 24 04          	mov    %eax,0x4(%esp)
     bdb:	c7 04 24 40 35 00 00 	movl   $0x3540,(%esp)
     be2:	e8 e5 21 00 00       	call   2dcc <open>
     be7:	85 c0                	test   %eax,%eax
     be9:	0f 89 ec 00 00 00    	jns    cdb <dirfile+0x15b>
     bef:	b8 00 02 00 00       	mov    $0x200,%eax
     bf4:	89 44 24 04          	mov    %eax,0x4(%esp)
     bf8:	c7 04 24 40 35 00 00 	movl   $0x3540,(%esp)
     bff:	e8 c8 21 00 00       	call   2dcc <open>
     c04:	85 c0                	test   %eax,%eax
     c06:	0f 89 cf 00 00 00    	jns    cdb <dirfile+0x15b>
     c0c:	c7 04 24 40 35 00 00 	movl   $0x3540,(%esp)
     c13:	e8 dc 21 00 00       	call   2df4 <mkdir>
     c18:	85 c0                	test   %eax,%eax
     c1a:	0f 84 09 01 00 00    	je     d29 <dirfile+0x1a9>
     c20:	c7 04 24 40 35 00 00 	movl   $0x3540,(%esp)
     c27:	e8 b0 21 00 00       	call   2ddc <unlink>
     c2c:	85 c0                	test   %eax,%eax
     c2e:	0f 84 0f 01 00 00    	je     d43 <dirfile+0x1c3>
     c34:	b8 40 35 00 00       	mov    $0x3540,%eax
     c39:	89 44 24 04          	mov    %eax,0x4(%esp)
     c3d:	c7 04 24 38 33 00 00 	movl   $0x3338,(%esp)
     c44:	e8 a3 21 00 00       	call   2dec <link>
     c49:	85 c0                	test   %eax,%eax
     c4b:	0f 84 0c 01 00 00    	je     d5d <dirfile+0x1dd>
     c51:	c7 04 24 07 35 00 00 	movl   $0x3507,(%esp)
     c58:	e8 7f 21 00 00       	call   2ddc <unlink>
     c5d:	85 c0                	test   %eax,%eax
     c5f:	0f 85 12 01 00 00    	jne    d77 <dirfile+0x1f7>
     c65:	ba 02 00 00 00       	mov    $0x2,%edx
     c6a:	89 54 24 04          	mov    %edx,0x4(%esp)
     c6e:	c7 04 24 c8 37 00 00 	movl   $0x37c8,(%esp)
     c75:	e8 52 21 00 00       	call   2dcc <open>
     c7a:	85 c0                	test   %eax,%eax
     c7c:	0f 89 0f 01 00 00    	jns    d91 <dirfile+0x211>
     c82:	31 c0                	xor    %eax,%eax
     c84:	89 44 24 04          	mov    %eax,0x4(%esp)
     c88:	c7 04 24 c8 37 00 00 	movl   $0x37c8,(%esp)
     c8f:	e8 38 21 00 00       	call   2dcc <open>
     c94:	89 c3                	mov    %eax,%ebx
     c96:	b8 01 00 00 00       	mov    $0x1,%eax
     c9b:	89 44 24 08          	mov    %eax,0x8(%esp)
     c9f:	b8 ab 38 00 00       	mov    $0x38ab,%eax
     ca4:	89 44 24 04          	mov    %eax,0x4(%esp)
     ca8:	89 1c 24             	mov    %ebx,(%esp)
     cab:	e8 fc 20 00 00       	call   2dac <write>
     cb0:	85 c0                	test   %eax,%eax
     cb2:	0f 8f f3 00 00 00    	jg     dab <dirfile+0x22b>
     cb8:	89 1c 24             	mov    %ebx,(%esp)
     cbb:	e8 f4 20 00 00       	call   2db4 <close>
     cc0:	b8 d0 35 00 00       	mov    $0x35d0,%eax
     cc5:	89 44 24 04          	mov    %eax,0x4(%esp)
     cc9:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     cd0:	e8 1b 22 00 00       	call   2ef0 <printf>
     cd5:	83 c4 14             	add    $0x14,%esp
     cd8:	5b                   	pop    %ebx
     cd9:	5d                   	pop    %ebp
     cda:	c3                   	ret    
     cdb:	b8 4b 35 00 00       	mov    $0x354b,%eax
     ce0:	89 44 24 04          	mov    %eax,0x4(%esp)
     ce4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     ceb:	e8 00 22 00 00       	call   2ef0 <printf>
     cf0:	e8 97 20 00 00       	call   2d8c <exit>
     cf5:	b9 0f 35 00 00       	mov    $0x350f,%ecx
     cfa:	89 4c 24 04          	mov    %ecx,0x4(%esp)
     cfe:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     d05:	e8 e6 21 00 00       	call   2ef0 <printf>
     d0a:	e8 7d 20 00 00       	call   2d8c <exit>
     d0f:	ba 26 35 00 00       	mov    $0x3526,%edx
     d14:	89 54 24 04          	mov    %edx,0x4(%esp)
     d18:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     d1f:	e8 cc 21 00 00       	call   2ef0 <printf>
     d24:	e8 63 20 00 00       	call   2d8c <exit>
     d29:	b8 69 35 00 00       	mov    $0x3569,%eax
     d2e:	89 44 24 04          	mov    %eax,0x4(%esp)
     d32:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     d39:	e8 b2 21 00 00       	call   2ef0 <printf>
     d3e:	e8 49 20 00 00       	call   2d8c <exit>
     d43:	b8 86 35 00 00       	mov    $0x3586,%eax
     d48:	89 44 24 04          	mov    %eax,0x4(%esp)
     d4c:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     d53:	e8 98 21 00 00       	call   2ef0 <printf>
     d58:	e8 2f 20 00 00       	call   2d8c <exit>
     d5d:	bb 2c 41 00 00       	mov    $0x412c,%ebx
     d62:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     d66:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     d6d:	e8 7e 21 00 00       	call   2ef0 <printf>
     d72:	e8 15 20 00 00       	call   2d8c <exit>
     d77:	b9 a4 35 00 00       	mov    $0x35a4,%ecx
     d7c:	89 4c 24 04          	mov    %ecx,0x4(%esp)
     d80:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     d87:	e8 64 21 00 00       	call   2ef0 <printf>
     d8c:	e8 fb 1f 00 00       	call   2d8c <exit>
     d91:	b8 4c 41 00 00       	mov    $0x414c,%eax
     d96:	89 44 24 04          	mov    %eax,0x4(%esp)
     d9a:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     da1:	e8 4a 21 00 00       	call   2ef0 <printf>
     da6:	e8 e1 1f 00 00       	call   2d8c <exit>
     dab:	b8 bc 35 00 00       	mov    $0x35bc,%eax
     db0:	89 44 24 04          	mov    %eax,0x4(%esp)
     db4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     dbb:	e8 30 21 00 00       	call   2ef0 <printf>
     dc0:	e8 c7 1f 00 00       	call   2d8c <exit>
     dc5:	8d 74 26 00          	lea    0x0(%esi),%esi
     dc9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00000dd0 <bigfile>:
     dd0:	55                   	push   %ebp
     dd1:	b8 e0 35 00 00       	mov    $0x35e0,%eax
     dd6:	89 e5                	mov    %esp,%ebp
     dd8:	57                   	push   %edi
     dd9:	56                   	push   %esi
     dda:	53                   	push   %ebx
     ddb:	31 db                	xor    %ebx,%ebx
     ddd:	83 ec 0c             	sub    $0xc,%esp
     de0:	89 44 24 04          	mov    %eax,0x4(%esp)
     de4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     deb:	e8 00 21 00 00       	call   2ef0 <printf>
     df0:	c7 04 24 fc 35 00 00 	movl   $0x35fc,(%esp)
     df7:	e8 e0 1f 00 00       	call   2ddc <unlink>
     dfc:	b8 02 02 00 00       	mov    $0x202,%eax
     e01:	89 44 24 04          	mov    %eax,0x4(%esp)
     e05:	c7 04 24 fc 35 00 00 	movl   $0x35fc,(%esp)
     e0c:	e8 bb 1f 00 00       	call   2dcc <open>
     e11:	85 c0                	test   %eax,%eax
     e13:	89 c6                	mov    %eax,%esi
     e15:	0f 88 6c 01 00 00    	js     f87 <bigfile+0x1b7>
     e1b:	90                   	nop    
     e1c:	8d 74 26 00          	lea    0x0(%esi),%esi
     e20:	b8 58 02 00 00       	mov    $0x258,%eax
     e25:	89 44 24 08          	mov    %eax,0x8(%esp)
     e29:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     e2d:	c7 04 24 80 44 00 00 	movl   $0x4480,(%esp)
     e34:	e8 a7 1d 00 00       	call   2be0 <memset>
     e39:	b8 58 02 00 00       	mov    $0x258,%eax
     e3e:	89 44 24 08          	mov    %eax,0x8(%esp)
     e42:	b8 80 44 00 00       	mov    $0x4480,%eax
     e47:	89 44 24 04          	mov    %eax,0x4(%esp)
     e4b:	89 34 24             	mov    %esi,(%esp)
     e4e:	e8 59 1f 00 00       	call   2dac <write>
     e53:	3d 58 02 00 00       	cmp    $0x258,%eax
     e58:	0f 85 0f 01 00 00    	jne    f6d <bigfile+0x19d>
     e5e:	43                   	inc    %ebx
     e5f:	83 fb 14             	cmp    $0x14,%ebx
     e62:	75 bc                	jne    e20 <bigfile+0x50>
     e64:	89 34 24             	mov    %esi,(%esp)
     e67:	31 f6                	xor    %esi,%esi
     e69:	e8 46 1f 00 00       	call   2db4 <close>
     e6e:	89 74 24 04          	mov    %esi,0x4(%esp)
     e72:	c7 04 24 fc 35 00 00 	movl   $0x35fc,(%esp)
     e79:	e8 4e 1f 00 00       	call   2dcc <open>
     e7e:	85 c0                	test   %eax,%eax
     e80:	89 c6                	mov    %eax,%esi
     e82:	0f 88 19 01 00 00    	js     fa1 <bigfile+0x1d1>
     e88:	31 db                	xor    %ebx,%ebx
     e8a:	31 ff                	xor    %edi,%edi
     e8c:	eb 33                	jmp    ec1 <bigfile+0xf1>
     e8e:	89 f6                	mov    %esi,%esi
     e90:	3d 2c 01 00 00       	cmp    $0x12c,%eax
     e95:	0f 85 b8 00 00 00    	jne    f53 <bigfile+0x183>
     e9b:	0f be 15 80 44 00 00 	movsbl 0x4480,%edx
     ea2:	89 d8                	mov    %ebx,%eax
     ea4:	c1 e8 1f             	shr    $0x1f,%eax
     ea7:	01 d8                	add    %ebx,%eax
     ea9:	d1 f8                	sar    %eax
     eab:	39 c2                	cmp    %eax,%edx
     ead:	75 70                	jne    f1f <bigfile+0x14f>
     eaf:	0f be 05 ab 45 00 00 	movsbl 0x45ab,%eax
     eb6:	39 c2                	cmp    %eax,%edx
     eb8:	75 65                	jne    f1f <bigfile+0x14f>
     eba:	81 c7 2c 01 00 00    	add    $0x12c,%edi
     ec0:	43                   	inc    %ebx
     ec1:	b9 2c 01 00 00       	mov    $0x12c,%ecx
     ec6:	ba 80 44 00 00       	mov    $0x4480,%edx
     ecb:	89 4c 24 08          	mov    %ecx,0x8(%esp)
     ecf:	89 54 24 04          	mov    %edx,0x4(%esp)
     ed3:	89 34 24             	mov    %esi,(%esp)
     ed6:	e8 c9 1e 00 00       	call   2da4 <read>
     edb:	83 f8 00             	cmp    $0x0,%eax
     ede:	7c 59                	jl     f39 <bigfile+0x169>
     ee0:	75 ae                	jne    e90 <bigfile+0xc0>
     ee2:	89 34 24             	mov    %esi,(%esp)
     ee5:	e8 ca 1e 00 00       	call   2db4 <close>
     eea:	81 ff e0 2e 00 00    	cmp    $0x2ee0,%edi
     ef0:	0f 85 c5 00 00 00    	jne    fbb <bigfile+0x1eb>
     ef6:	c7 04 24 fc 35 00 00 	movl   $0x35fc,(%esp)
     efd:	e8 da 1e 00 00       	call   2ddc <unlink>
     f02:	b8 8b 36 00 00       	mov    $0x368b,%eax
     f07:	89 44 24 04          	mov    %eax,0x4(%esp)
     f0b:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     f12:	e8 d9 1f 00 00       	call   2ef0 <printf>
     f17:	83 c4 0c             	add    $0xc,%esp
     f1a:	5b                   	pop    %ebx
     f1b:	5e                   	pop    %esi
     f1c:	5f                   	pop    %edi
     f1d:	5d                   	pop    %ebp
     f1e:	c3                   	ret    
     f1f:	b8 58 36 00 00       	mov    $0x3658,%eax
     f24:	89 44 24 04          	mov    %eax,0x4(%esp)
     f28:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     f2f:	e8 bc 1f 00 00       	call   2ef0 <printf>
     f34:	e8 53 1e 00 00       	call   2d8c <exit>
     f39:	b8 2f 36 00 00       	mov    $0x362f,%eax
     f3e:	89 44 24 04          	mov    %eax,0x4(%esp)
     f42:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     f49:	e8 a2 1f 00 00       	call   2ef0 <printf>
     f4e:	e8 39 1e 00 00       	call   2d8c <exit>
     f53:	b8 44 36 00 00       	mov    $0x3644,%eax
     f58:	89 44 24 04          	mov    %eax,0x4(%esp)
     f5c:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     f63:	e8 88 1f 00 00       	call   2ef0 <printf>
     f68:	e8 1f 1e 00 00       	call   2d8c <exit>
     f6d:	bf 04 36 00 00       	mov    $0x3604,%edi
     f72:	89 7c 24 04          	mov    %edi,0x4(%esp)
     f76:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     f7d:	e8 6e 1f 00 00       	call   2ef0 <printf>
     f82:	e8 05 1e 00 00       	call   2d8c <exit>
     f87:	b8 ee 35 00 00       	mov    $0x35ee,%eax
     f8c:	89 44 24 04          	mov    %eax,0x4(%esp)
     f90:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     f97:	e8 54 1f 00 00       	call   2ef0 <printf>
     f9c:	e8 eb 1d 00 00       	call   2d8c <exit>
     fa1:	bb 1a 36 00 00       	mov    $0x361a,%ebx
     fa6:	89 5c 24 04          	mov    %ebx,0x4(%esp)
     faa:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     fb1:	e8 3a 1f 00 00       	call   2ef0 <printf>
     fb6:	e8 d1 1d 00 00       	call   2d8c <exit>
     fbb:	b8 71 36 00 00       	mov    $0x3671,%eax
     fc0:	89 44 24 04          	mov    %eax,0x4(%esp)
     fc4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     fcb:	e8 20 1f 00 00       	call   2ef0 <printf>
     fd0:	e8 b7 1d 00 00       	call   2d8c <exit>
     fd5:	8d 74 26 00          	lea    0x0(%esi),%esi
     fd9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00000fe0 <subdir>:
     fe0:	55                   	push   %ebp
     fe1:	b8 9c 36 00 00       	mov    $0x369c,%eax
     fe6:	89 e5                	mov    %esp,%ebp
     fe8:	53                   	push   %ebx
     fe9:	83 ec 14             	sub    $0x14,%esp
     fec:	89 44 24 04          	mov    %eax,0x4(%esp)
     ff0:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
     ff7:	e8 f4 1e 00 00       	call   2ef0 <printf>
     ffc:	c7 04 24 25 37 00 00 	movl   $0x3725,(%esp)
    1003:	e8 d4 1d 00 00       	call   2ddc <unlink>
    1008:	c7 04 24 c2 37 00 00 	movl   $0x37c2,(%esp)
    100f:	e8 e0 1d 00 00       	call   2df4 <mkdir>
    1014:	85 c0                	test   %eax,%eax
    1016:	0f 85 ff 03 00 00    	jne    141b <subdir+0x43b>
    101c:	b8 02 02 00 00       	mov    $0x202,%eax
    1021:	89 44 24 04          	mov    %eax,0x4(%esp)
    1025:	c7 04 24 fb 36 00 00 	movl   $0x36fb,(%esp)
    102c:	e8 9b 1d 00 00       	call   2dcc <open>
    1031:	85 c0                	test   %eax,%eax
    1033:	89 c3                	mov    %eax,%ebx
    1035:	0f 88 fa 03 00 00    	js     1435 <subdir+0x455>
    103b:	b9 02 00 00 00       	mov    $0x2,%ecx
    1040:	ba 25 37 00 00       	mov    $0x3725,%edx
    1045:	89 4c 24 08          	mov    %ecx,0x8(%esp)
    1049:	89 54 24 04          	mov    %edx,0x4(%esp)
    104d:	89 04 24             	mov    %eax,(%esp)
    1050:	e8 57 1d 00 00       	call   2dac <write>
    1055:	89 1c 24             	mov    %ebx,(%esp)
    1058:	e8 57 1d 00 00       	call   2db4 <close>
    105d:	c7 04 24 c2 37 00 00 	movl   $0x37c2,(%esp)
    1064:	e8 73 1d 00 00       	call   2ddc <unlink>
    1069:	85 c0                	test   %eax,%eax
    106b:	0f 89 de 03 00 00    	jns    144f <subdir+0x46f>
    1071:	c7 04 24 d6 36 00 00 	movl   $0x36d6,(%esp)
    1078:	e8 77 1d 00 00       	call   2df4 <mkdir>
    107d:	85 c0                	test   %eax,%eax
    107f:	0f 85 e4 03 00 00    	jne    1469 <subdir+0x489>
    1085:	b8 02 02 00 00       	mov    $0x202,%eax
    108a:	89 44 24 04          	mov    %eax,0x4(%esp)
    108e:	c7 04 24 f8 36 00 00 	movl   $0x36f8,(%esp)
    1095:	e8 32 1d 00 00       	call   2dcc <open>
    109a:	85 c0                	test   %eax,%eax
    109c:	89 c3                	mov    %eax,%ebx
    109e:	0f 88 df 03 00 00    	js     1483 <subdir+0x4a3>
    10a4:	b8 02 00 00 00       	mov    $0x2,%eax
    10a9:	89 44 24 08          	mov    %eax,0x8(%esp)
    10ad:	b8 19 37 00 00       	mov    $0x3719,%eax
    10b2:	89 1c 24             	mov    %ebx,(%esp)
    10b5:	89 44 24 04          	mov    %eax,0x4(%esp)
    10b9:	e8 ee 1c 00 00       	call   2dac <write>
    10be:	89 1c 24             	mov    %ebx,(%esp)
    10c1:	31 db                	xor    %ebx,%ebx
    10c3:	e8 ec 1c 00 00       	call   2db4 <close>
    10c8:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    10cc:	c7 04 24 1c 37 00 00 	movl   $0x371c,(%esp)
    10d3:	e8 f4 1c 00 00       	call   2dcc <open>
    10d8:	85 c0                	test   %eax,%eax
    10da:	89 c3                	mov    %eax,%ebx
    10dc:	0f 88 bb 03 00 00    	js     149d <subdir+0x4bd>
    10e2:	ba 00 08 00 00       	mov    $0x800,%edx
    10e7:	b8 80 44 00 00       	mov    $0x4480,%eax
    10ec:	89 54 24 08          	mov    %edx,0x8(%esp)
    10f0:	89 44 24 04          	mov    %eax,0x4(%esp)
    10f4:	89 1c 24             	mov    %ebx,(%esp)
    10f7:	e8 a8 1c 00 00       	call   2da4 <read>
    10fc:	83 f8 02             	cmp    $0x2,%eax
    10ff:	75 09                	jne    110a <subdir+0x12a>
    1101:	80 3d 80 44 00 00 66 	cmpb   $0x66,0x4480
    1108:	74 1a                	je     1124 <subdir+0x144>
    110a:	b8 41 37 00 00       	mov    $0x3741,%eax
    110f:	89 44 24 04          	mov    %eax,0x4(%esp)
    1113:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    111a:	e8 d1 1d 00 00       	call   2ef0 <printf>
    111f:	e8 68 1c 00 00       	call   2d8c <exit>
    1124:	89 1c 24             	mov    %ebx,(%esp)
    1127:	e8 88 1c 00 00       	call   2db4 <close>
    112c:	b8 5c 37 00 00       	mov    $0x375c,%eax
    1131:	89 44 24 04          	mov    %eax,0x4(%esp)
    1135:	c7 04 24 f8 36 00 00 	movl   $0x36f8,(%esp)
    113c:	e8 ab 1c 00 00       	call   2dec <link>
    1141:	85 c0                	test   %eax,%eax
    1143:	0f 85 bc 03 00 00    	jne    1505 <subdir+0x525>
    1149:	c7 04 24 f8 36 00 00 	movl   $0x36f8,(%esp)
    1150:	e8 87 1c 00 00       	call   2ddc <unlink>
    1155:	85 c0                	test   %eax,%eax
    1157:	0f 85 74 03 00 00    	jne    14d1 <subdir+0x4f1>
    115d:	31 c0                	xor    %eax,%eax
    115f:	89 44 24 04          	mov    %eax,0x4(%esp)
    1163:	c7 04 24 f8 36 00 00 	movl   $0x36f8,(%esp)
    116a:	e8 5d 1c 00 00       	call   2dcc <open>
    116f:	85 c0                	test   %eax,%eax
    1171:	0f 89 74 03 00 00    	jns    14eb <subdir+0x50b>
    1177:	c7 04 24 c2 37 00 00 	movl   $0x37c2,(%esp)
    117e:	e8 79 1c 00 00       	call   2dfc <chdir>
    1183:	85 c0                	test   %eax,%eax
    1185:	0f 85 94 03 00 00    	jne    151f <subdir+0x53f>
    118b:	c7 04 24 90 37 00 00 	movl   $0x3790,(%esp)
    1192:	e8 65 1c 00 00       	call   2dfc <chdir>
    1197:	85 c0                	test   %eax,%eax
    1199:	0f 85 18 03 00 00    	jne    14b7 <subdir+0x4d7>
    119f:	c7 04 24 b6 37 00 00 	movl   $0x37b6,(%esp)
    11a6:	e8 51 1c 00 00       	call   2dfc <chdir>
    11ab:	85 c0                	test   %eax,%eax
    11ad:	0f 85 04 03 00 00    	jne    14b7 <subdir+0x4d7>
    11b3:	c7 04 24 c5 37 00 00 	movl   $0x37c5,(%esp)
    11ba:	e8 3d 1c 00 00       	call   2dfc <chdir>
    11bf:	85 c0                	test   %eax,%eax
    11c1:	0f 85 8c 03 00 00    	jne    1553 <subdir+0x573>
    11c7:	31 c0                	xor    %eax,%eax
    11c9:	89 44 24 04          	mov    %eax,0x4(%esp)
    11cd:	c7 04 24 5c 37 00 00 	movl   $0x375c,(%esp)
    11d4:	e8 f3 1b 00 00       	call   2dcc <open>
    11d9:	85 c0                	test   %eax,%eax
    11db:	89 c3                	mov    %eax,%ebx
    11dd:	0f 88 56 03 00 00    	js     1539 <subdir+0x559>
    11e3:	b8 00 08 00 00       	mov    $0x800,%eax
    11e8:	89 44 24 08          	mov    %eax,0x8(%esp)
    11ec:	b8 80 44 00 00       	mov    $0x4480,%eax
    11f1:	89 44 24 04          	mov    %eax,0x4(%esp)
    11f5:	89 1c 24             	mov    %ebx,(%esp)
    11f8:	e8 a7 1b 00 00       	call   2da4 <read>
    11fd:	83 f8 02             	cmp    $0x2,%eax
    1200:	0f 85 9b 03 00 00    	jne    15a1 <subdir+0x5c1>
    1206:	89 1c 24             	mov    %ebx,(%esp)
    1209:	e8 a6 1b 00 00       	call   2db4 <close>
    120e:	31 c0                	xor    %eax,%eax
    1210:	89 44 24 04          	mov    %eax,0x4(%esp)
    1214:	c7 04 24 f8 36 00 00 	movl   $0x36f8,(%esp)
    121b:	e8 ac 1b 00 00       	call   2dcc <open>
    1220:	85 c0                	test   %eax,%eax
    1222:	0f 89 5f 03 00 00    	jns    1587 <subdir+0x5a7>
    1228:	b9 02 02 00 00       	mov    $0x202,%ecx
    122d:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    1231:	c7 04 24 10 38 00 00 	movl   $0x3810,(%esp)
    1238:	e8 8f 1b 00 00       	call   2dcc <open>
    123d:	85 c0                	test   %eax,%eax
    123f:	0f 89 28 03 00 00    	jns    156d <subdir+0x58d>
    1245:	b8 02 02 00 00       	mov    $0x202,%eax
    124a:	89 44 24 04          	mov    %eax,0x4(%esp)
    124e:	c7 04 24 35 38 00 00 	movl   $0x3835,(%esp)
    1255:	e8 72 1b 00 00       	call   2dcc <open>
    125a:	85 c0                	test   %eax,%eax
    125c:	0f 89 59 03 00 00    	jns    15bb <subdir+0x5db>
    1262:	b8 00 02 00 00       	mov    $0x200,%eax
    1267:	89 44 24 04          	mov    %eax,0x4(%esp)
    126b:	c7 04 24 c2 37 00 00 	movl   $0x37c2,(%esp)
    1272:	e8 55 1b 00 00       	call   2dcc <open>
    1277:	85 c0                	test   %eax,%eax
    1279:	0f 89 f2 03 00 00    	jns    1671 <subdir+0x691>
    127f:	b8 02 00 00 00       	mov    $0x2,%eax
    1284:	89 44 24 04          	mov    %eax,0x4(%esp)
    1288:	c7 04 24 c2 37 00 00 	movl   $0x37c2,(%esp)
    128f:	e8 38 1b 00 00       	call   2dcc <open>
    1294:	85 c0                	test   %eax,%eax
    1296:	0f 89 bb 03 00 00    	jns    1657 <subdir+0x677>
    129c:	bb 01 00 00 00       	mov    $0x1,%ebx
    12a1:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    12a5:	c7 04 24 c2 37 00 00 	movl   $0x37c2,(%esp)
    12ac:	e8 1b 1b 00 00       	call   2dcc <open>
    12b1:	85 c0                	test   %eax,%eax
    12b3:	0f 89 84 03 00 00    	jns    163d <subdir+0x65d>
    12b9:	ba a4 38 00 00       	mov    $0x38a4,%edx
    12be:	89 54 24 04          	mov    %edx,0x4(%esp)
    12c2:	c7 04 24 10 38 00 00 	movl   $0x3810,(%esp)
    12c9:	e8 1e 1b 00 00       	call   2dec <link>
    12ce:	85 c0                	test   %eax,%eax
    12d0:	0f 84 4d 03 00 00    	je     1623 <subdir+0x643>
    12d6:	b8 a4 38 00 00       	mov    $0x38a4,%eax
    12db:	89 44 24 04          	mov    %eax,0x4(%esp)
    12df:	c7 04 24 35 38 00 00 	movl   $0x3835,(%esp)
    12e6:	e8 01 1b 00 00       	call   2dec <link>
    12eb:	85 c0                	test   %eax,%eax
    12ed:	0f 84 16 03 00 00    	je     1609 <subdir+0x629>
    12f3:	b8 5c 37 00 00       	mov    $0x375c,%eax
    12f8:	89 44 24 04          	mov    %eax,0x4(%esp)
    12fc:	c7 04 24 fb 36 00 00 	movl   $0x36fb,(%esp)
    1303:	e8 e4 1a 00 00       	call   2dec <link>
    1308:	85 c0                	test   %eax,%eax
    130a:	0f 84 df 02 00 00    	je     15ef <subdir+0x60f>
    1310:	c7 04 24 10 38 00 00 	movl   $0x3810,(%esp)
    1317:	e8 d8 1a 00 00       	call   2df4 <mkdir>
    131c:	85 c0                	test   %eax,%eax
    131e:	0f 84 b1 02 00 00    	je     15d5 <subdir+0x5f5>
    1324:	c7 04 24 35 38 00 00 	movl   $0x3835,(%esp)
    132b:	e8 c4 1a 00 00       	call   2df4 <mkdir>
    1330:	85 c0                	test   %eax,%eax
    1332:	0f 84 53 03 00 00    	je     168b <subdir+0x6ab>
    1338:	c7 04 24 5c 37 00 00 	movl   $0x375c,(%esp)
    133f:	e8 b0 1a 00 00       	call   2df4 <mkdir>
    1344:	85 c0                	test   %eax,%eax
    1346:	0f 84 f5 03 00 00    	je     1741 <subdir+0x761>
    134c:	c7 04 24 35 38 00 00 	movl   $0x3835,(%esp)
    1353:	e8 84 1a 00 00       	call   2ddc <unlink>
    1358:	85 c0                	test   %eax,%eax
    135a:	0f 84 c7 03 00 00    	je     1727 <subdir+0x747>
    1360:	c7 04 24 10 38 00 00 	movl   $0x3810,(%esp)
    1367:	e8 70 1a 00 00       	call   2ddc <unlink>
    136c:	85 c0                	test   %eax,%eax
    136e:	0f 84 99 03 00 00    	je     170d <subdir+0x72d>
    1374:	c7 04 24 fb 36 00 00 	movl   $0x36fb,(%esp)
    137b:	e8 7c 1a 00 00       	call   2dfc <chdir>
    1380:	85 c0                	test   %eax,%eax
    1382:	0f 84 6b 03 00 00    	je     16f3 <subdir+0x713>
    1388:	c7 04 24 a7 38 00 00 	movl   $0x38a7,(%esp)
    138f:	e8 68 1a 00 00       	call   2dfc <chdir>
    1394:	85 c0                	test   %eax,%eax
    1396:	0f 84 3d 03 00 00    	je     16d9 <subdir+0x6f9>
    139c:	c7 04 24 5c 37 00 00 	movl   $0x375c,(%esp)
    13a3:	e8 34 1a 00 00       	call   2ddc <unlink>
    13a8:	85 c0                	test   %eax,%eax
    13aa:	0f 85 21 01 00 00    	jne    14d1 <subdir+0x4f1>
    13b0:	c7 04 24 fb 36 00 00 	movl   $0x36fb,(%esp)
    13b7:	e8 20 1a 00 00       	call   2ddc <unlink>
    13bc:	85 c0                	test   %eax,%eax
    13be:	0f 85 fb 02 00 00    	jne    16bf <subdir+0x6df>
    13c4:	c7 04 24 c2 37 00 00 	movl   $0x37c2,(%esp)
    13cb:	e8 0c 1a 00 00       	call   2ddc <unlink>
    13d0:	85 c0                	test   %eax,%eax
    13d2:	0f 84 cd 02 00 00    	je     16a5 <subdir+0x6c5>
    13d8:	c7 04 24 d7 36 00 00 	movl   $0x36d7,(%esp)
    13df:	e8 f8 19 00 00       	call   2ddc <unlink>
    13e4:	85 c0                	test   %eax,%eax
    13e6:	0f 88 89 03 00 00    	js     1775 <subdir+0x795>
    13ec:	c7 04 24 c2 37 00 00 	movl   $0x37c2,(%esp)
    13f3:	e8 e4 19 00 00       	call   2ddc <unlink>
    13f8:	85 c0                	test   %eax,%eax
    13fa:	0f 88 5b 03 00 00    	js     175b <subdir+0x77b>
    1400:	ba a4 39 00 00       	mov    $0x39a4,%edx
    1405:	89 54 24 04          	mov    %edx,0x4(%esp)
    1409:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1410:	e8 db 1a 00 00       	call   2ef0 <printf>
    1415:	83 c4 14             	add    $0x14,%esp
    1418:	5b                   	pop    %ebx
    1419:	5d                   	pop    %ebp
    141a:	c3                   	ret    
    141b:	b8 a9 36 00 00       	mov    $0x36a9,%eax
    1420:	89 44 24 04          	mov    %eax,0x4(%esp)
    1424:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    142b:	e8 c0 1a 00 00       	call   2ef0 <printf>
    1430:	e8 57 19 00 00       	call   2d8c <exit>
    1435:	bb c1 36 00 00       	mov    $0x36c1,%ebx
    143a:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    143e:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1445:	e8 a6 1a 00 00       	call   2ef0 <printf>
    144a:	e8 3d 19 00 00       	call   2d8c <exit>
    144f:	b8 6c 41 00 00       	mov    $0x416c,%eax
    1454:	89 44 24 04          	mov    %eax,0x4(%esp)
    1458:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    145f:	e8 8c 1a 00 00       	call   2ef0 <printf>
    1464:	e8 23 19 00 00       	call   2d8c <exit>
    1469:	b8 dd 36 00 00       	mov    $0x36dd,%eax
    146e:	89 44 24 04          	mov    %eax,0x4(%esp)
    1472:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1479:	e8 72 1a 00 00       	call   2ef0 <printf>
    147e:	e8 09 19 00 00       	call   2d8c <exit>
    1483:	b8 01 37 00 00       	mov    $0x3701,%eax
    1488:	89 44 24 04          	mov    %eax,0x4(%esp)
    148c:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1493:	e8 58 1a 00 00       	call   2ef0 <printf>
    1498:	e8 ef 18 00 00       	call   2d8c <exit>
    149d:	b9 28 37 00 00       	mov    $0x3728,%ecx
    14a2:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    14a6:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    14ad:	e8 3e 1a 00 00       	call   2ef0 <printf>
    14b2:	e8 d5 18 00 00       	call   2d8c <exit>
    14b7:	b9 9c 37 00 00       	mov    $0x379c,%ecx
    14bc:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    14c0:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    14c7:	e8 24 1a 00 00       	call   2ef0 <printf>
    14cc:	e8 bb 18 00 00       	call   2d8c <exit>
    14d1:	b8 67 37 00 00       	mov    $0x3767,%eax
    14d6:	89 44 24 04          	mov    %eax,0x4(%esp)
    14da:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    14e1:	e8 0a 1a 00 00       	call   2ef0 <printf>
    14e6:	e8 a1 18 00 00       	call   2d8c <exit>
    14eb:	b8 b8 41 00 00       	mov    $0x41b8,%eax
    14f0:	89 44 24 04          	mov    %eax,0x4(%esp)
    14f4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    14fb:	e8 f0 19 00 00       	call   2ef0 <printf>
    1500:	e8 87 18 00 00       	call   2d8c <exit>
    1505:	b8 94 41 00 00       	mov    $0x4194,%eax
    150a:	89 44 24 04          	mov    %eax,0x4(%esp)
    150e:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1515:	e8 d6 19 00 00       	call   2ef0 <printf>
    151a:	e8 6d 18 00 00       	call   2d8c <exit>
    151f:	bb 7f 37 00 00       	mov    $0x377f,%ebx
    1524:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1528:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    152f:	e8 bc 19 00 00       	call   2ef0 <printf>
    1534:	e8 53 18 00 00       	call   2d8c <exit>
    1539:	b8 dd 37 00 00       	mov    $0x37dd,%eax
    153e:	89 44 24 04          	mov    %eax,0x4(%esp)
    1542:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1549:	e8 a2 19 00 00       	call   2ef0 <printf>
    154e:	e8 39 18 00 00       	call   2d8c <exit>
    1553:	ba ca 37 00 00       	mov    $0x37ca,%edx
    1558:	89 54 24 04          	mov    %edx,0x4(%esp)
    155c:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1563:	e8 88 19 00 00       	call   2ef0 <printf>
    1568:	e8 1f 18 00 00       	call   2d8c <exit>
    156d:	ba 19 38 00 00       	mov    $0x3819,%edx
    1572:	89 54 24 04          	mov    %edx,0x4(%esp)
    1576:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    157d:	e8 6e 19 00 00       	call   2ef0 <printf>
    1582:	e8 05 18 00 00       	call   2d8c <exit>
    1587:	bb dc 41 00 00       	mov    $0x41dc,%ebx
    158c:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1590:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1597:	e8 54 19 00 00       	call   2ef0 <printf>
    159c:	e8 eb 17 00 00       	call   2d8c <exit>
    15a1:	b8 f5 37 00 00       	mov    $0x37f5,%eax
    15a6:	89 44 24 04          	mov    %eax,0x4(%esp)
    15aa:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    15b1:	e8 3a 19 00 00       	call   2ef0 <printf>
    15b6:	e8 d1 17 00 00       	call   2d8c <exit>
    15bb:	b8 3e 38 00 00       	mov    $0x383e,%eax
    15c0:	89 44 24 04          	mov    %eax,0x4(%esp)
    15c4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    15cb:	e8 20 19 00 00       	call   2ef0 <printf>
    15d0:	e8 b7 17 00 00       	call   2d8c <exit>
    15d5:	b8 ad 38 00 00       	mov    $0x38ad,%eax
    15da:	89 44 24 04          	mov    %eax,0x4(%esp)
    15de:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    15e5:	e8 06 19 00 00       	call   2ef0 <printf>
    15ea:	e8 9d 17 00 00       	call   2d8c <exit>
    15ef:	b8 4c 42 00 00       	mov    $0x424c,%eax
    15f4:	89 44 24 04          	mov    %eax,0x4(%esp)
    15f8:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    15ff:	e8 ec 18 00 00       	call   2ef0 <printf>
    1604:	e8 83 17 00 00       	call   2d8c <exit>
    1609:	b8 28 42 00 00       	mov    $0x4228,%eax
    160e:	89 44 24 04          	mov    %eax,0x4(%esp)
    1612:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1619:	e8 d2 18 00 00       	call   2ef0 <printf>
    161e:	e8 69 17 00 00       	call   2d8c <exit>
    1623:	b8 04 42 00 00       	mov    $0x4204,%eax
    1628:	89 44 24 04          	mov    %eax,0x4(%esp)
    162c:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1633:	e8 b8 18 00 00       	call   2ef0 <printf>
    1638:	e8 4f 17 00 00       	call   2d8c <exit>
    163d:	b9 89 38 00 00       	mov    $0x3889,%ecx
    1642:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    1646:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    164d:	e8 9e 18 00 00       	call   2ef0 <printf>
    1652:	e8 35 17 00 00       	call   2d8c <exit>
    1657:	b8 70 38 00 00       	mov    $0x3870,%eax
    165c:	89 44 24 04          	mov    %eax,0x4(%esp)
    1660:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1667:	e8 84 18 00 00       	call   2ef0 <printf>
    166c:	e8 1b 17 00 00       	call   2d8c <exit>
    1671:	b8 5a 38 00 00       	mov    $0x385a,%eax
    1676:	89 44 24 04          	mov    %eax,0x4(%esp)
    167a:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1681:	e8 6a 18 00 00       	call   2ef0 <printf>
    1686:	e8 01 17 00 00       	call   2d8c <exit>
    168b:	bb c8 38 00 00       	mov    $0x38c8,%ebx
    1690:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1694:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    169b:	e8 50 18 00 00       	call   2ef0 <printf>
    16a0:	e8 e7 16 00 00       	call   2d8c <exit>
    16a5:	b8 70 42 00 00       	mov    $0x4270,%eax
    16aa:	89 44 24 04          	mov    %eax,0x4(%esp)
    16ae:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    16b5:	e8 36 18 00 00       	call   2ef0 <printf>
    16ba:	e8 cd 16 00 00       	call   2d8c <exit>
    16bf:	b8 68 39 00 00       	mov    $0x3968,%eax
    16c4:	89 44 24 04          	mov    %eax,0x4(%esp)
    16c8:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    16cf:	e8 1c 18 00 00       	call   2ef0 <printf>
    16d4:	e8 b3 16 00 00       	call   2d8c <exit>
    16d9:	b8 50 39 00 00       	mov    $0x3950,%eax
    16de:	89 44 24 04          	mov    %eax,0x4(%esp)
    16e2:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    16e9:	e8 02 18 00 00       	call   2ef0 <printf>
    16ee:	e8 99 16 00 00       	call   2d8c <exit>
    16f3:	b8 38 39 00 00       	mov    $0x3938,%eax
    16f8:	89 44 24 04          	mov    %eax,0x4(%esp)
    16fc:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1703:	e8 e8 17 00 00       	call   2ef0 <printf>
    1708:	e8 7f 16 00 00       	call   2d8c <exit>
    170d:	b8 1c 39 00 00       	mov    $0x391c,%eax
    1712:	89 44 24 04          	mov    %eax,0x4(%esp)
    1716:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    171d:	e8 ce 17 00 00       	call   2ef0 <printf>
    1722:	e8 65 16 00 00       	call   2d8c <exit>
    1727:	ba 00 39 00 00       	mov    $0x3900,%edx
    172c:	89 54 24 04          	mov    %edx,0x4(%esp)
    1730:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1737:	e8 b4 17 00 00       	call   2ef0 <printf>
    173c:	e8 4b 16 00 00       	call   2d8c <exit>
    1741:	b9 e3 38 00 00       	mov    $0x38e3,%ecx
    1746:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    174a:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1751:	e8 9a 17 00 00       	call   2ef0 <printf>
    1756:	e8 31 16 00 00       	call   2d8c <exit>
    175b:	b9 92 39 00 00       	mov    $0x3992,%ecx
    1760:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    1764:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    176b:	e8 80 17 00 00       	call   2ef0 <printf>
    1770:	e8 17 16 00 00       	call   2d8c <exit>
    1775:	bb 7d 39 00 00       	mov    $0x397d,%ebx
    177a:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    177e:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1785:	e8 66 17 00 00       	call   2ef0 <printf>
    178a:	e8 fd 15 00 00       	call   2d8c <exit>
    178f:	90                   	nop    

00001790 <concreate>:
    1790:	55                   	push   %ebp
    1791:	b8 af 39 00 00       	mov    $0x39af,%eax
    1796:	89 e5                	mov    %esp,%ebp
    1798:	57                   	push   %edi
    1799:	56                   	push   %esi
    179a:	53                   	push   %ebx
    179b:	31 db                	xor    %ebx,%ebx
    179d:	83 ec 5c             	sub    $0x5c,%esp
    17a0:	89 44 24 04          	mov    %eax,0x4(%esp)
    17a4:	8d 7d f1             	lea    0xfffffff1(%ebp),%edi
    17a7:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    17ae:	e8 3d 17 00 00       	call   2ef0 <printf>
    17b3:	c6 45 f1 43          	movb   $0x43,0xfffffff1(%ebp)
    17b7:	c6 45 f3 00          	movb   $0x0,0xfffffff3(%ebp)
    17bb:	90                   	nop    
    17bc:	8d 74 26 00          	lea    0x0(%esi),%esi
    17c0:	88 d8                	mov    %bl,%al
    17c2:	04 30                	add    $0x30,%al
    17c4:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
    17c7:	89 3c 24             	mov    %edi,(%esp)
    17ca:	e8 0d 16 00 00       	call   2ddc <unlink>
    17cf:	e8 b0 15 00 00       	call   2d84 <fork>
    17d4:	85 c0                	test   %eax,%eax
    17d6:	89 c6                	mov    %eax,%esi
    17d8:	0f 84 e9 00 00 00    	je     18c7 <concreate+0x137>
    17de:	89 d8                	mov    %ebx,%eax
    17e0:	ba 56 55 55 55       	mov    $0x55555556,%edx
    17e5:	f7 ea                	imul   %edx
    17e7:	89 d8                	mov    %ebx,%eax
    17e9:	c1 f8 1f             	sar    $0x1f,%eax
    17ec:	29 c2                	sub    %eax,%edx
    17ee:	89 d8                	mov    %ebx,%eax
    17f0:	8d 14 52             	lea    (%edx,%edx,2),%edx
    17f3:	29 d0                	sub    %edx,%eax
    17f5:	48                   	dec    %eax
    17f6:	0f 84 00 01 00 00    	je     18fc <concreate+0x16c>
    17fc:	b8 02 02 00 00       	mov    $0x202,%eax
    1801:	89 44 24 04          	mov    %eax,0x4(%esp)
    1805:	89 3c 24             	mov    %edi,(%esp)
    1808:	e8 bf 15 00 00       	call   2dcc <open>
    180d:	85 c0                	test   %eax,%eax
    180f:	0f 88 9e 01 00 00    	js     19b3 <concreate+0x223>
    1815:	89 04 24             	mov    %eax,(%esp)
    1818:	e8 97 15 00 00       	call   2db4 <close>
    181d:	85 f6                	test   %esi,%esi
    181f:	90                   	nop    
    1820:	0f 84 d1 00 00 00    	je     18f7 <concreate+0x167>
    1826:	43                   	inc    %ebx
    1827:	e8 68 15 00 00       	call   2d94 <wait>
    182c:	83 fb 28             	cmp    $0x28,%ebx
    182f:	90                   	nop    
    1830:	75 8e                	jne    17c0 <concreate+0x30>
    1832:	b8 28 00 00 00       	mov    $0x28,%eax
    1837:	89 44 24 08          	mov    %eax,0x8(%esp)
    183b:	31 c0                	xor    %eax,%eax
    183d:	89 44 24 04          	mov    %eax,0x4(%esp)
    1841:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
    1844:	89 04 24             	mov    %eax,(%esp)
    1847:	8d 75 e0             	lea    0xffffffe0(%ebp),%esi
    184a:	e8 91 13 00 00       	call   2be0 <memset>
    184f:	31 c0                	xor    %eax,%eax
    1851:	89 44 24 04          	mov    %eax,0x4(%esp)
    1855:	c7 04 24 c8 37 00 00 	movl   $0x37c8,(%esp)
    185c:	e8 6b 15 00 00       	call   2dcc <open>
    1861:	c7 45 b0 00 00 00 00 	movl   $0x0,0xffffffb0(%ebp)
    1868:	89 c3                	mov    %eax,%ebx
    186a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    1870:	b9 10 00 00 00       	mov    $0x10,%ecx
    1875:	89 4c 24 08          	mov    %ecx,0x8(%esp)
    1879:	89 74 24 04          	mov    %esi,0x4(%esp)
    187d:	89 1c 24             	mov    %ebx,(%esp)
    1880:	e8 1f 15 00 00       	call   2da4 <read>
    1885:	85 c0                	test   %eax,%eax
    1887:	0f 8e 84 00 00 00    	jle    1911 <concreate+0x181>
    188d:	66 83 7d e0 00       	cmpw   $0x0,0xffffffe0(%ebp)
    1892:	74 dc                	je     1870 <concreate+0xe0>
    1894:	80 7d e2 43          	cmpb   $0x43,0xffffffe2(%ebp)
    1898:	75 d6                	jne    1870 <concreate+0xe0>
    189a:	80 7d e4 00          	cmpb   $0x0,0xffffffe4(%ebp)
    189e:	89 f6                	mov    %esi,%esi
    18a0:	75 ce                	jne    1870 <concreate+0xe0>
    18a2:	0f be 45 e3          	movsbl 0xffffffe3(%ebp),%eax
    18a6:	83 e8 30             	sub    $0x30,%eax
    18a9:	83 f8 27             	cmp    $0x27,%eax
    18ac:	0f 87 39 01 00 00    	ja     19eb <concreate+0x25b>
    18b2:	80 7c 05 b8 00       	cmpb   $0x0,0xffffffb8(%ebp,%eax,1)
    18b7:	0f 85 4f 01 00 00    	jne    1a0c <concreate+0x27c>
    18bd:	c6 44 05 b8 01       	movb   $0x1,0xffffffb8(%ebp,%eax,1)
    18c2:	ff 45 b0             	incl   0xffffffb0(%ebp)
    18c5:	eb a9                	jmp    1870 <concreate+0xe0>
    18c7:	89 d8                	mov    %ebx,%eax
    18c9:	ba 67 66 66 66       	mov    $0x66666667,%edx
    18ce:	f7 ea                	imul   %edx
    18d0:	89 d8                	mov    %ebx,%eax
    18d2:	c1 f8 1f             	sar    $0x1f,%eax
    18d5:	d1 fa                	sar    %edx
    18d7:	29 c2                	sub    %eax,%edx
    18d9:	89 d8                	mov    %ebx,%eax
    18db:	8d 14 92             	lea    (%edx,%edx,4),%edx
    18de:	29 d0                	sub    %edx,%eax
    18e0:	48                   	dec    %eax
    18e1:	0f 85 15 ff ff ff    	jne    17fc <concreate+0x6c>
    18e7:	89 7c 24 04          	mov    %edi,0x4(%esp)
    18eb:	c7 04 24 bf 39 00 00 	movl   $0x39bf,(%esp)
    18f2:	e8 f5 14 00 00       	call   2dec <link>
    18f7:	e8 90 14 00 00       	call   2d8c <exit>
    18fc:	89 7c 24 04          	mov    %edi,0x4(%esp)
    1900:	c7 04 24 bf 39 00 00 	movl   $0x39bf,(%esp)
    1907:	e8 e0 14 00 00       	call   2dec <link>
    190c:	e9 15 ff ff ff       	jmp    1826 <concreate+0x96>
    1911:	89 1c 24             	mov    %ebx,(%esp)
    1914:	31 f6                	xor    %esi,%esi
    1916:	e8 99 14 00 00       	call   2db4 <close>
    191b:	83 7d b0 28          	cmpl   $0x28,0xffffffb0(%ebp)
    191f:	90                   	nop    
    1920:	74 27                	je     1949 <concreate+0x1b9>
    1922:	e9 06 01 00 00       	jmp    1a2d <concreate+0x29d>
    1927:	48                   	dec    %eax
    1928:	90                   	nop    
    1929:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
    1930:	74 5e                	je     1990 <concreate+0x200>
    1932:	89 3c 24             	mov    %edi,(%esp)
    1935:	e8 a2 14 00 00       	call   2ddc <unlink>
    193a:	85 db                	test   %ebx,%ebx
    193c:	74 b9                	je     18f7 <concreate+0x167>
    193e:	46                   	inc    %esi
    193f:	e8 50 14 00 00       	call   2d94 <wait>
    1944:	83 fe 28             	cmp    $0x28,%esi
    1947:	74 4d                	je     1996 <concreate+0x206>
    1949:	89 f0                	mov    %esi,%eax
    194b:	04 30                	add    $0x30,%al
    194d:	88 45 f2             	mov    %al,0xfffffff2(%ebp)
    1950:	e8 2f 14 00 00       	call   2d84 <fork>
    1955:	85 c0                	test   %eax,%eax
    1957:	89 c3                	mov    %eax,%ebx
    1959:	78 76                	js     19d1 <concreate+0x241>
    195b:	89 f0                	mov    %esi,%eax
    195d:	ba 56 55 55 55       	mov    $0x55555556,%edx
    1962:	f7 ea                	imul   %edx
    1964:	89 f0                	mov    %esi,%eax
    1966:	c1 f8 1f             	sar    $0x1f,%eax
    1969:	29 c2                	sub    %eax,%edx
    196b:	89 f0                	mov    %esi,%eax
    196d:	8d 14 52             	lea    (%edx,%edx,2),%edx
    1970:	29 d0                	sub    %edx,%eax
    1972:	89 da                	mov    %ebx,%edx
    1974:	09 c2                	or     %eax,%edx
    1976:	75 af                	jne    1927 <concreate+0x197>
    1978:	31 c0                	xor    %eax,%eax
    197a:	89 44 24 04          	mov    %eax,0x4(%esp)
    197e:	89 3c 24             	mov    %edi,(%esp)
    1981:	e8 46 14 00 00       	call   2dcc <open>
    1986:	89 04 24             	mov    %eax,(%esp)
    1989:	e8 26 14 00 00       	call   2db4 <close>
    198e:	eb aa                	jmp    193a <concreate+0x1aa>
    1990:	85 db                	test   %ebx,%ebx
    1992:	74 9e                	je     1932 <concreate+0x1a2>
    1994:	eb e2                	jmp    1978 <concreate+0x1e8>
    1996:	b8 14 3a 00 00       	mov    $0x3a14,%eax
    199b:	89 44 24 04          	mov    %eax,0x4(%esp)
    199f:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    19a6:	e8 45 15 00 00       	call   2ef0 <printf>
    19ab:	83 c4 5c             	add    $0x5c,%esp
    19ae:	5b                   	pop    %ebx
    19af:	5e                   	pop    %esi
    19b0:	5f                   	pop    %edi
    19b1:	5d                   	pop    %ebp
    19b2:	c3                   	ret    
    19b3:	b8 c2 39 00 00       	mov    $0x39c2,%eax
    19b8:	89 44 24 04          	mov    %eax,0x4(%esp)
    19bc:	89 7c 24 08          	mov    %edi,0x8(%esp)
    19c0:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    19c7:	e8 24 15 00 00       	call   2ef0 <printf>
    19cc:	e8 bb 13 00 00       	call   2d8c <exit>
    19d1:	b8 78 32 00 00       	mov    $0x3278,%eax
    19d6:	89 44 24 04          	mov    %eax,0x4(%esp)
    19da:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    19e1:	e8 0a 15 00 00       	call   2ef0 <printf>
    19e6:	e8 a1 13 00 00       	call   2d8c <exit>
    19eb:	8d 55 e2             	lea    0xffffffe2(%ebp),%edx
    19ee:	be de 39 00 00       	mov    $0x39de,%esi
    19f3:	89 54 24 08          	mov    %edx,0x8(%esp)
    19f7:	89 74 24 04          	mov    %esi,0x4(%esp)
    19fb:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1a02:	e8 e9 14 00 00       	call   2ef0 <printf>
    1a07:	e9 eb fe ff ff       	jmp    18f7 <concreate+0x167>
    1a0c:	8d 45 e2             	lea    0xffffffe2(%ebp),%eax
    1a0f:	bb f7 39 00 00       	mov    $0x39f7,%ebx
    1a14:	89 44 24 08          	mov    %eax,0x8(%esp)
    1a18:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1a1c:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1a23:	e8 c8 14 00 00       	call   2ef0 <printf>
    1a28:	e9 ca fe ff ff       	jmp    18f7 <concreate+0x167>
    1a2d:	ba 90 42 00 00       	mov    $0x4290,%edx
    1a32:	89 54 24 04          	mov    %edx,0x4(%esp)
    1a36:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1a3d:	e8 ae 14 00 00       	call   2ef0 <printf>
    1a42:	e8 45 13 00 00       	call   2d8c <exit>
    1a47:	89 f6                	mov    %esi,%esi
    1a49:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00001a50 <linktest>:
    1a50:	55                   	push   %ebp
    1a51:	b8 22 3a 00 00       	mov    $0x3a22,%eax
    1a56:	89 e5                	mov    %esp,%ebp
    1a58:	53                   	push   %ebx
    1a59:	bb 02 02 00 00       	mov    $0x202,%ebx
    1a5e:	83 ec 14             	sub    $0x14,%esp
    1a61:	89 44 24 04          	mov    %eax,0x4(%esp)
    1a65:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1a6c:	e8 7f 14 00 00       	call   2ef0 <printf>
    1a71:	c7 04 24 2c 3a 00 00 	movl   $0x3a2c,(%esp)
    1a78:	e8 5f 13 00 00       	call   2ddc <unlink>
    1a7d:	c7 04 24 30 3a 00 00 	movl   $0x3a30,(%esp)
    1a84:	e8 53 13 00 00       	call   2ddc <unlink>
    1a89:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1a8d:	c7 04 24 2c 3a 00 00 	movl   $0x3a2c,(%esp)
    1a94:	e8 33 13 00 00       	call   2dcc <open>
    1a99:	85 c0                	test   %eax,%eax
    1a9b:	89 c3                	mov    %eax,%ebx
    1a9d:	0f 88 33 01 00 00    	js     1bd6 <linktest+0x186>
    1aa3:	ba 05 00 00 00       	mov    $0x5,%edx
    1aa8:	b8 47 3a 00 00       	mov    $0x3a47,%eax
    1aad:	89 54 24 08          	mov    %edx,0x8(%esp)
    1ab1:	89 44 24 04          	mov    %eax,0x4(%esp)
    1ab5:	89 1c 24             	mov    %ebx,(%esp)
    1ab8:	e8 ef 12 00 00       	call   2dac <write>
    1abd:	83 f8 05             	cmp    $0x5,%eax
    1ac0:	0f 85 2a 01 00 00    	jne    1bf0 <linktest+0x1a0>
    1ac6:	89 1c 24             	mov    %ebx,(%esp)
    1ac9:	e8 e6 12 00 00       	call   2db4 <close>
    1ace:	b8 30 3a 00 00       	mov    $0x3a30,%eax
    1ad3:	89 44 24 04          	mov    %eax,0x4(%esp)
    1ad7:	c7 04 24 2c 3a 00 00 	movl   $0x3a2c,(%esp)
    1ade:	e8 09 13 00 00       	call   2dec <link>
    1ae3:	85 c0                	test   %eax,%eax
    1ae5:	0f 88 1f 01 00 00    	js     1c0a <linktest+0x1ba>
    1aeb:	c7 04 24 2c 3a 00 00 	movl   $0x3a2c,(%esp)
    1af2:	e8 e5 12 00 00       	call   2ddc <unlink>
    1af7:	31 c0                	xor    %eax,%eax
    1af9:	89 44 24 04          	mov    %eax,0x4(%esp)
    1afd:	c7 04 24 2c 3a 00 00 	movl   $0x3a2c,(%esp)
    1b04:	e8 c3 12 00 00       	call   2dcc <open>
    1b09:	85 c0                	test   %eax,%eax
    1b0b:	0f 89 13 01 00 00    	jns    1c24 <linktest+0x1d4>
    1b11:	31 db                	xor    %ebx,%ebx
    1b13:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1b17:	c7 04 24 30 3a 00 00 	movl   $0x3a30,(%esp)
    1b1e:	e8 a9 12 00 00       	call   2dcc <open>
    1b23:	85 c0                	test   %eax,%eax
    1b25:	89 c3                	mov    %eax,%ebx
    1b27:	0f 88 11 01 00 00    	js     1c3e <linktest+0x1ee>
    1b2d:	ba 00 08 00 00       	mov    $0x800,%edx
    1b32:	b8 80 44 00 00       	mov    $0x4480,%eax
    1b37:	89 54 24 08          	mov    %edx,0x8(%esp)
    1b3b:	89 44 24 04          	mov    %eax,0x4(%esp)
    1b3f:	89 1c 24             	mov    %ebx,(%esp)
    1b42:	e8 5d 12 00 00       	call   2da4 <read>
    1b47:	83 f8 05             	cmp    $0x5,%eax
    1b4a:	0f 85 08 01 00 00    	jne    1c58 <linktest+0x208>
    1b50:	89 1c 24             	mov    %ebx,(%esp)
    1b53:	e8 5c 12 00 00       	call   2db4 <close>
    1b58:	b8 30 3a 00 00       	mov    $0x3a30,%eax
    1b5d:	89 44 24 04          	mov    %eax,0x4(%esp)
    1b61:	c7 04 24 30 3a 00 00 	movl   $0x3a30,(%esp)
    1b68:	e8 7f 12 00 00       	call   2dec <link>
    1b6d:	85 c0                	test   %eax,%eax
    1b6f:	0f 89 fd 00 00 00    	jns    1c72 <linktest+0x222>
    1b75:	c7 04 24 30 3a 00 00 	movl   $0x3a30,(%esp)
    1b7c:	e8 5b 12 00 00       	call   2ddc <unlink>
    1b81:	b8 2c 3a 00 00       	mov    $0x3a2c,%eax
    1b86:	89 44 24 04          	mov    %eax,0x4(%esp)
    1b8a:	c7 04 24 30 3a 00 00 	movl   $0x3a30,(%esp)
    1b91:	e8 56 12 00 00       	call   2dec <link>
    1b96:	85 c0                	test   %eax,%eax
    1b98:	0f 89 ee 00 00 00    	jns    1c8c <linktest+0x23c>
    1b9e:	bb 2c 3a 00 00       	mov    $0x3a2c,%ebx
    1ba3:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1ba7:	c7 04 24 c8 37 00 00 	movl   $0x37c8,(%esp)
    1bae:	e8 39 12 00 00       	call   2dec <link>
    1bb3:	85 c0                	test   %eax,%eax
    1bb5:	0f 89 eb 00 00 00    	jns    1ca6 <linktest+0x256>
    1bbb:	ba d0 3a 00 00       	mov    $0x3ad0,%edx
    1bc0:	89 54 24 04          	mov    %edx,0x4(%esp)
    1bc4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1bcb:	e8 20 13 00 00       	call   2ef0 <printf>
    1bd0:	83 c4 14             	add    $0x14,%esp
    1bd3:	5b                   	pop    %ebx
    1bd4:	5d                   	pop    %ebp
    1bd5:	c3                   	ret    
    1bd6:	b9 34 3a 00 00       	mov    $0x3a34,%ecx
    1bdb:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    1bdf:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1be6:	e8 05 13 00 00       	call   2ef0 <printf>
    1beb:	e8 9c 11 00 00       	call   2d8c <exit>
    1bf0:	b8 4d 3a 00 00       	mov    $0x3a4d,%eax
    1bf5:	89 44 24 04          	mov    %eax,0x4(%esp)
    1bf9:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1c00:	e8 eb 12 00 00       	call   2ef0 <printf>
    1c05:	e8 82 11 00 00       	call   2d8c <exit>
    1c0a:	b8 5f 3a 00 00       	mov    $0x3a5f,%eax
    1c0f:	89 44 24 04          	mov    %eax,0x4(%esp)
    1c13:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1c1a:	e8 d1 12 00 00       	call   2ef0 <printf>
    1c1f:	e8 68 11 00 00       	call   2d8c <exit>
    1c24:	b8 c4 42 00 00       	mov    $0x42c4,%eax
    1c29:	89 44 24 04          	mov    %eax,0x4(%esp)
    1c2d:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1c34:	e8 b7 12 00 00       	call   2ef0 <printf>
    1c39:	e8 4e 11 00 00       	call   2d8c <exit>
    1c3e:	b9 74 3a 00 00       	mov    $0x3a74,%ecx
    1c43:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    1c47:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1c4e:	e8 9d 12 00 00       	call   2ef0 <printf>
    1c53:	e8 34 11 00 00       	call   2d8c <exit>
    1c58:	b8 85 3a 00 00       	mov    $0x3a85,%eax
    1c5d:	89 44 24 04          	mov    %eax,0x4(%esp)
    1c61:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1c68:	e8 83 12 00 00       	call   2ef0 <printf>
    1c6d:	e8 1a 11 00 00       	call   2d8c <exit>
    1c72:	b8 96 3a 00 00       	mov    $0x3a96,%eax
    1c77:	89 44 24 04          	mov    %eax,0x4(%esp)
    1c7b:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1c82:	e8 69 12 00 00       	call   2ef0 <printf>
    1c87:	e8 00 11 00 00       	call   2d8c <exit>
    1c8c:	b8 ec 42 00 00       	mov    $0x42ec,%eax
    1c91:	89 44 24 04          	mov    %eax,0x4(%esp)
    1c95:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1c9c:	e8 4f 12 00 00       	call   2ef0 <printf>
    1ca1:	e8 e6 10 00 00       	call   2d8c <exit>
    1ca6:	b9 b4 3a 00 00       	mov    $0x3ab4,%ecx
    1cab:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    1caf:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1cb6:	e8 35 12 00 00       	call   2ef0 <printf>
    1cbb:	e8 cc 10 00 00       	call   2d8c <exit>

00001cc0 <unlinkread>:
    1cc0:	55                   	push   %ebp
    1cc1:	b8 dd 3a 00 00       	mov    $0x3add,%eax
    1cc6:	89 e5                	mov    %esp,%ebp
    1cc8:	56                   	push   %esi
    1cc9:	be 02 02 00 00       	mov    $0x202,%esi
    1cce:	53                   	push   %ebx
    1ccf:	83 ec 10             	sub    $0x10,%esp
    1cd2:	89 44 24 04          	mov    %eax,0x4(%esp)
    1cd6:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1cdd:	e8 0e 12 00 00       	call   2ef0 <printf>
    1ce2:	89 74 24 04          	mov    %esi,0x4(%esp)
    1ce6:	c7 04 24 ee 3a 00 00 	movl   $0x3aee,(%esp)
    1ced:	e8 da 10 00 00       	call   2dcc <open>
    1cf2:	85 c0                	test   %eax,%eax
    1cf4:	89 c3                	mov    %eax,%ebx
    1cf6:	0f 88 11 01 00 00    	js     1e0d <unlinkread+0x14d>
    1cfc:	b9 05 00 00 00       	mov    $0x5,%ecx
    1d01:	ba 47 3a 00 00       	mov    $0x3a47,%edx
    1d06:	89 4c 24 08          	mov    %ecx,0x8(%esp)
    1d0a:	89 54 24 04          	mov    %edx,0x4(%esp)
    1d0e:	89 04 24             	mov    %eax,(%esp)
    1d11:	e8 96 10 00 00       	call   2dac <write>
    1d16:	89 1c 24             	mov    %ebx,(%esp)
    1d19:	e8 96 10 00 00       	call   2db4 <close>
    1d1e:	b8 02 00 00 00       	mov    $0x2,%eax
    1d23:	89 44 24 04          	mov    %eax,0x4(%esp)
    1d27:	c7 04 24 ee 3a 00 00 	movl   $0x3aee,(%esp)
    1d2e:	e8 99 10 00 00       	call   2dcc <open>
    1d33:	85 c0                	test   %eax,%eax
    1d35:	89 c6                	mov    %eax,%esi
    1d37:	0f 88 ea 00 00 00    	js     1e27 <unlinkread+0x167>
    1d3d:	c7 04 24 ee 3a 00 00 	movl   $0x3aee,(%esp)
    1d44:	e8 93 10 00 00       	call   2ddc <unlink>
    1d49:	85 c0                	test   %eax,%eax
    1d4b:	0f 85 f0 00 00 00    	jne    1e41 <unlinkread+0x181>
    1d51:	b8 02 02 00 00       	mov    $0x202,%eax
    1d56:	89 44 24 04          	mov    %eax,0x4(%esp)
    1d5a:	c7 04 24 ee 3a 00 00 	movl   $0x3aee,(%esp)
    1d61:	e8 66 10 00 00       	call   2dcc <open>
    1d66:	89 c3                	mov    %eax,%ebx
    1d68:	b8 03 00 00 00       	mov    $0x3,%eax
    1d6d:	89 44 24 08          	mov    %eax,0x8(%esp)
    1d71:	b8 45 3b 00 00       	mov    $0x3b45,%eax
    1d76:	89 1c 24             	mov    %ebx,(%esp)
    1d79:	89 44 24 04          	mov    %eax,0x4(%esp)
    1d7d:	e8 2a 10 00 00       	call   2dac <write>
    1d82:	89 1c 24             	mov    %ebx,(%esp)
    1d85:	bb 00 08 00 00       	mov    $0x800,%ebx
    1d8a:	e8 25 10 00 00       	call   2db4 <close>
    1d8f:	b9 80 44 00 00       	mov    $0x4480,%ecx
    1d94:	89 5c 24 08          	mov    %ebx,0x8(%esp)
    1d98:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    1d9c:	89 34 24             	mov    %esi,(%esp)
    1d9f:	e8 00 10 00 00       	call   2da4 <read>
    1da4:	83 f8 05             	cmp    $0x5,%eax
    1da7:	0f 85 ae 00 00 00    	jne    1e5b <unlinkread+0x19b>
    1dad:	80 3d 80 44 00 00 68 	cmpb   $0x68,0x4480
    1db4:	0f 85 bb 00 00 00    	jne    1e75 <unlinkread+0x1b5>
    1dba:	b8 0a 00 00 00       	mov    $0xa,%eax
    1dbf:	89 44 24 08          	mov    %eax,0x8(%esp)
    1dc3:	b8 80 44 00 00       	mov    $0x4480,%eax
    1dc8:	89 44 24 04          	mov    %eax,0x4(%esp)
    1dcc:	89 34 24             	mov    %esi,(%esp)
    1dcf:	e8 d8 0f 00 00       	call   2dac <write>
    1dd4:	83 f8 0a             	cmp    $0xa,%eax
    1dd7:	0f 85 b2 00 00 00    	jne    1e8f <unlinkread+0x1cf>
    1ddd:	89 34 24             	mov    %esi,(%esp)
    1de0:	e8 cf 0f 00 00       	call   2db4 <close>
    1de5:	c7 04 24 ee 3a 00 00 	movl   $0x3aee,(%esp)
    1dec:	e8 eb 0f 00 00       	call   2ddc <unlink>
    1df1:	b8 90 3b 00 00       	mov    $0x3b90,%eax
    1df6:	89 44 24 04          	mov    %eax,0x4(%esp)
    1dfa:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1e01:	e8 ea 10 00 00       	call   2ef0 <printf>
    1e06:	83 c4 10             	add    $0x10,%esp
    1e09:	5b                   	pop    %ebx
    1e0a:	5e                   	pop    %esi
    1e0b:	5d                   	pop    %ebp
    1e0c:	c3                   	ret    
    1e0d:	bb f9 3a 00 00       	mov    $0x3af9,%ebx
    1e12:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1e16:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1e1d:	e8 ce 10 00 00       	call   2ef0 <printf>
    1e22:	e8 65 0f 00 00       	call   2d8c <exit>
    1e27:	b8 13 3b 00 00       	mov    $0x3b13,%eax
    1e2c:	89 44 24 04          	mov    %eax,0x4(%esp)
    1e30:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1e37:	e8 b4 10 00 00       	call   2ef0 <printf>
    1e3c:	e8 4b 0f 00 00       	call   2d8c <exit>
    1e41:	b8 2b 3b 00 00       	mov    $0x3b2b,%eax
    1e46:	89 44 24 04          	mov    %eax,0x4(%esp)
    1e4a:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1e51:	e8 9a 10 00 00       	call   2ef0 <printf>
    1e56:	e8 31 0f 00 00       	call   2d8c <exit>
    1e5b:	ba 49 3b 00 00       	mov    $0x3b49,%edx
    1e60:	89 54 24 04          	mov    %edx,0x4(%esp)
    1e64:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1e6b:	e8 80 10 00 00       	call   2ef0 <printf>
    1e70:	e8 17 0f 00 00       	call   2d8c <exit>
    1e75:	b8 60 3b 00 00       	mov    $0x3b60,%eax
    1e7a:	89 44 24 04          	mov    %eax,0x4(%esp)
    1e7e:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1e85:	e8 66 10 00 00       	call   2ef0 <printf>
    1e8a:	e8 fd 0e 00 00       	call   2d8c <exit>
    1e8f:	b8 77 3b 00 00       	mov    $0x3b77,%eax
    1e94:	89 44 24 04          	mov    %eax,0x4(%esp)
    1e98:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1e9f:	e8 4c 10 00 00       	call   2ef0 <printf>
    1ea4:	e8 e3 0e 00 00       	call   2d8c <exit>
    1ea9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00001eb0 <twofiles>:
    1eb0:	55                   	push   %ebp
    1eb1:	89 e5                	mov    %esp,%ebp
    1eb3:	57                   	push   %edi
    1eb4:	bf 9f 3b 00 00       	mov    $0x3b9f,%edi
    1eb9:	56                   	push   %esi
    1eba:	53                   	push   %ebx
    1ebb:	83 ec 1c             	sub    $0x1c,%esp
    1ebe:	89 7c 24 04          	mov    %edi,0x4(%esp)
    1ec2:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    1ec9:	e8 22 10 00 00       	call   2ef0 <printf>
    1ece:	c7 04 24 2d 3a 00 00 	movl   $0x3a2d,(%esp)
    1ed5:	e8 02 0f 00 00       	call   2ddc <unlink>
    1eda:	c7 04 24 31 3a 00 00 	movl   $0x3a31,(%esp)
    1ee1:	e8 f6 0e 00 00       	call   2ddc <unlink>
    1ee6:	e8 99 0e 00 00       	call   2d84 <fork>
    1eeb:	83 f8 00             	cmp    $0x0,%eax
    1eee:	89 c7                	mov    %eax,%edi
    1ef0:	0f 8c 9d 01 00 00    	jl     2093 <twofiles+0x1e3>
    1ef6:	0f 85 03 01 00 00    	jne    1fff <twofiles+0x14f>
    1efc:	b8 31 3a 00 00       	mov    $0x3a31,%eax
    1f01:	bb 02 02 00 00       	mov    $0x202,%ebx
    1f06:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    1f0a:	89 04 24             	mov    %eax,(%esp)
    1f0d:	e8 ba 0e 00 00       	call   2dcc <open>
    1f12:	85 c0                	test   %eax,%eax
    1f14:	89 c6                	mov    %eax,%esi
    1f16:	0f 88 b2 01 00 00    	js     20ce <twofiles+0x21e>
    1f1c:	83 ff 01             	cmp    $0x1,%edi
    1f1f:	ba 00 02 00 00       	mov    $0x200,%edx
    1f24:	19 c0                	sbb    %eax,%eax
    1f26:	31 db                	xor    %ebx,%ebx
    1f28:	83 e0 f3             	and    $0xfffffff3,%eax
    1f2b:	83 c0 70             	add    $0x70,%eax
    1f2e:	89 54 24 08          	mov    %edx,0x8(%esp)
    1f32:	89 44 24 04          	mov    %eax,0x4(%esp)
    1f36:	c7 04 24 80 44 00 00 	movl   $0x4480,(%esp)
    1f3d:	e8 9e 0c 00 00       	call   2be0 <memset>
    1f42:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
    1f49:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi
    1f50:	b8 f4 01 00 00       	mov    $0x1f4,%eax
    1f55:	89 44 24 08          	mov    %eax,0x8(%esp)
    1f59:	b8 80 44 00 00       	mov    $0x4480,%eax
    1f5e:	89 44 24 04          	mov    %eax,0x4(%esp)
    1f62:	89 34 24             	mov    %esi,(%esp)
    1f65:	e8 42 0e 00 00       	call   2dac <write>
    1f6a:	3d f4 01 00 00       	cmp    $0x1f4,%eax
    1f6f:	0f 85 3b 01 00 00    	jne    20b0 <twofiles+0x200>
    1f75:	43                   	inc    %ebx
    1f76:	83 fb 0c             	cmp    $0xc,%ebx
    1f79:	75 d5                	jne    1f50 <twofiles+0xa0>
    1f7b:	89 34 24             	mov    %esi,(%esp)
    1f7e:	e8 31 0e 00 00       	call   2db4 <close>
    1f83:	85 ff                	test   %edi,%edi
    1f85:	0f 84 97 00 00 00    	je     2022 <twofiles+0x172>
    1f8b:	e8 04 0e 00 00       	call   2d94 <wait>
    1f90:	31 f6                	xor    %esi,%esi
    1f92:	85 f6                	test   %esi,%esi
    1f94:	b8 31 3a 00 00       	mov    $0x3a31,%eax
    1f99:	74 05                	je     1fa0 <twofiles+0xf0>
    1f9b:	b8 2d 3a 00 00       	mov    $0x3a2d,%eax
    1fa0:	31 d2                	xor    %edx,%edx
    1fa2:	31 ff                	xor    %edi,%edi
    1fa4:	89 54 24 04          	mov    %edx,0x4(%esp)
    1fa8:	89 04 24             	mov    %eax,(%esp)
    1fab:	e8 1c 0e 00 00       	call   2dcc <open>
    1fb0:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
    1fb3:	b8 00 08 00 00       	mov    $0x800,%eax
    1fb8:	89 44 24 08          	mov    %eax,0x8(%esp)
    1fbc:	b8 80 44 00 00       	mov    $0x4480,%eax
    1fc1:	89 44 24 04          	mov    %eax,0x4(%esp)
    1fc5:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    1fc8:	89 04 24             	mov    %eax,(%esp)
    1fcb:	e8 d4 0d 00 00       	call   2da4 <read>
    1fd0:	85 c0                	test   %eax,%eax
    1fd2:	89 c3                	mov    %eax,%ebx
    1fd4:	7e 6b                	jle    2041 <twofiles+0x191>
    1fd6:	31 c9                	xor    %ecx,%ecx
    1fd8:	90                   	nop    
    1fd9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
    1fe0:	83 fe 01             	cmp    $0x1,%esi
    1fe3:	0f be 91 80 44 00 00 	movsbl 0x4480(%ecx),%edx
    1fea:	19 c0                	sbb    %eax,%eax
    1fec:	83 e0 f3             	and    $0xfffffff3,%eax
    1fef:	83 c0 70             	add    $0x70,%eax
    1ff2:	39 d0                	cmp    %edx,%eax
    1ff4:	75 31                	jne    2027 <twofiles+0x177>
    1ff6:	41                   	inc    %ecx
    1ff7:	39 cb                	cmp    %ecx,%ebx
    1ff9:	75 e5                	jne    1fe0 <twofiles+0x130>
    1ffb:	01 df                	add    %ebx,%edi
    1ffd:	eb b4                	jmp    1fb3 <twofiles+0x103>
    1fff:	b8 2d 3a 00 00       	mov    $0x3a2d,%eax
    2004:	e9 f8 fe ff ff       	jmp    1f01 <twofiles+0x51>
    2009:	b8 cb 3b 00 00       	mov    $0x3bcb,%eax
    200e:	89 7c 24 08          	mov    %edi,0x8(%esp)
    2012:	89 44 24 04          	mov    %eax,0x4(%esp)
    2016:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    201d:	e8 ce 0e 00 00       	call   2ef0 <printf>
    2022:	e8 65 0d 00 00       	call   2d8c <exit>
    2027:	b8 bf 3b 00 00       	mov    $0x3bbf,%eax
    202c:	89 44 24 04          	mov    %eax,0x4(%esp)
    2030:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2037:	e8 b4 0e 00 00       	call   2ef0 <printf>
    203c:	e8 4b 0d 00 00       	call   2d8c <exit>
    2041:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    2044:	89 04 24             	mov    %eax,(%esp)
    2047:	e8 68 0d 00 00       	call   2db4 <close>
    204c:	81 ff 70 17 00 00    	cmp    $0x1770,%edi
    2052:	75 b5                	jne    2009 <twofiles+0x159>
    2054:	46                   	inc    %esi
    2055:	83 fe 02             	cmp    $0x2,%esi
    2058:	0f 85 34 ff ff ff    	jne    1f92 <twofiles+0xe2>
    205e:	c7 04 24 2d 3a 00 00 	movl   $0x3a2d,(%esp)
    2065:	e8 72 0d 00 00       	call   2ddc <unlink>
    206a:	c7 04 24 31 3a 00 00 	movl   $0x3a31,(%esp)
    2071:	e8 66 0d 00 00       	call   2ddc <unlink>
    2076:	b8 dc 3b 00 00       	mov    $0x3bdc,%eax
    207b:	89 44 24 04          	mov    %eax,0x4(%esp)
    207f:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2086:	e8 65 0e 00 00       	call   2ef0 <printf>
    208b:	83 c4 1c             	add    $0x1c,%esp
    208e:	5b                   	pop    %ebx
    208f:	5e                   	pop    %esi
    2090:	5f                   	pop    %edi
    2091:	5d                   	pop    %ebp
    2092:	c3                   	ret    
    2093:	be 78 32 00 00       	mov    $0x3278,%esi
    2098:	89 74 24 04          	mov    %esi,0x4(%esp)
    209c:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    20a3:	e8 48 0e 00 00       	call   2ef0 <printf>
    20a8:	83 c4 1c             	add    $0x1c,%esp
    20ab:	5b                   	pop    %ebx
    20ac:	5e                   	pop    %esi
    20ad:	5f                   	pop    %edi
    20ae:	5d                   	pop    %ebp
    20af:	c3                   	ret    
    20b0:	b9 ae 3b 00 00       	mov    $0x3bae,%ecx
    20b5:	89 44 24 08          	mov    %eax,0x8(%esp)
    20b9:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    20bd:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    20c4:	e8 27 0e 00 00       	call   2ef0 <printf>
    20c9:	e8 be 0c 00 00       	call   2d8c <exit>
    20ce:	b9 2d 34 00 00       	mov    $0x342d,%ecx
    20d3:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    20d7:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    20de:	e8 0d 0e 00 00       	call   2ef0 <printf>
    20e3:	e8 a4 0c 00 00       	call   2d8c <exit>
    20e8:	90                   	nop    
    20e9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

000020f0 <sharedfd>:
    20f0:	55                   	push   %ebp
    20f1:	89 e5                	mov    %esp,%ebp
    20f3:	57                   	push   %edi
    20f4:	56                   	push   %esi
    20f5:	53                   	push   %ebx
    20f6:	83 ec 2c             	sub    $0x2c,%esp
    20f9:	c7 04 24 e9 3b 00 00 	movl   $0x3be9,(%esp)
    2100:	e8 d7 0c 00 00       	call   2ddc <unlink>
    2105:	b8 02 02 00 00       	mov    $0x202,%eax
    210a:	89 44 24 04          	mov    %eax,0x4(%esp)
    210e:	c7 04 24 e9 3b 00 00 	movl   $0x3be9,(%esp)
    2115:	e8 b2 0c 00 00       	call   2dcc <open>
    211a:	85 c0                	test   %eax,%eax
    211c:	89 c7                	mov    %eax,%edi
    211e:	0f 88 39 01 00 00    	js     225d <sharedfd+0x16d>
    2124:	e8 5b 0c 00 00       	call   2d84 <fork>
    2129:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
    212c:	b8 70 00 00 00       	mov    $0x70,%eax
    2131:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
    2134:	85 f6                	test   %esi,%esi
    2136:	0f 84 17 01 00 00    	je     2253 <sharedfd+0x163>
    213c:	b9 0a 00 00 00       	mov    $0xa,%ecx
    2141:	31 db                	xor    %ebx,%ebx
    2143:	8d 75 ea             	lea    0xffffffea(%ebp),%esi
    2146:	89 4c 24 08          	mov    %ecx,0x8(%esp)
    214a:	89 44 24 04          	mov    %eax,0x4(%esp)
    214e:	89 34 24             	mov    %esi,(%esp)
    2151:	e8 8a 0a 00 00       	call   2be0 <memset>
    2156:	eb 09                	jmp    2161 <sharedfd+0x71>
    2158:	43                   	inc    %ebx
    2159:	81 fb e8 03 00 00    	cmp    $0x3e8,%ebx
    215f:	74 2f                	je     2190 <sharedfd+0xa0>
    2161:	ba 0a 00 00 00       	mov    $0xa,%edx
    2166:	89 54 24 08          	mov    %edx,0x8(%esp)
    216a:	89 74 24 04          	mov    %esi,0x4(%esp)
    216e:	89 3c 24             	mov    %edi,(%esp)
    2171:	e8 36 0c 00 00       	call   2dac <write>
    2176:	83 f8 0a             	cmp    $0xa,%eax
    2179:	74 dd                	je     2158 <sharedfd+0x68>
    217b:	bb 3c 43 00 00       	mov    $0x433c,%ebx
    2180:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    2184:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    218b:	e8 60 0d 00 00       	call   2ef0 <printf>
    2190:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
    2193:	85 c0                	test   %eax,%eax
    2195:	0f 84 1b 01 00 00    	je     22b6 <sharedfd+0x1c6>
    219b:	e8 f4 0b 00 00       	call   2d94 <wait>
    21a0:	89 3c 24             	mov    %edi,(%esp)
    21a3:	e8 0c 0c 00 00       	call   2db4 <close>
    21a8:	31 c0                	xor    %eax,%eax
    21aa:	89 44 24 04          	mov    %eax,0x4(%esp)
    21ae:	c7 04 24 e9 3b 00 00 	movl   $0x3be9,(%esp)
    21b5:	e8 12 0c 00 00       	call   2dcc <open>
    21ba:	85 c0                	test   %eax,%eax
    21bc:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
    21bf:	0f 88 d4 00 00 00    	js     2299 <sharedfd+0x1a9>
    21c5:	31 ff                	xor    %edi,%edi
    21c7:	31 db                	xor    %ebx,%ebx
    21c9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
    21d0:	b8 0a 00 00 00       	mov    $0xa,%eax
    21d5:	89 44 24 08          	mov    %eax,0x8(%esp)
    21d9:	89 74 24 04          	mov    %esi,0x4(%esp)
    21dd:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
    21e0:	89 04 24             	mov    %eax,(%esp)
    21e3:	e8 bc 0b 00 00       	call   2da4 <read>
    21e8:	85 c0                	test   %eax,%eax
    21ea:	7e 23                	jle    220f <sharedfd+0x11f>
    21ec:	ba 01 00 00 00       	mov    $0x1,%edx
    21f1:	eb 10                	jmp    2203 <sharedfd+0x113>
    21f3:	3c 70                	cmp    $0x70,%al
    21f5:	0f 94 c0             	sete   %al
    21f8:	0f b6 c0             	movzbl %al,%eax
    21fb:	01 c3                	add    %eax,%ebx
    21fd:	42                   	inc    %edx
    21fe:	83 fa 0b             	cmp    $0xb,%edx
    2201:	74 cd                	je     21d0 <sharedfd+0xe0>
    2203:	0f b6 44 32 ff       	movzbl 0xffffffff(%edx,%esi,1),%eax
    2208:	3c 63                	cmp    $0x63,%al
    220a:	75 e7                	jne    21f3 <sharedfd+0x103>
    220c:	47                   	inc    %edi
    220d:	eb ee                	jmp    21fd <sharedfd+0x10d>
    220f:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
    2212:	89 04 24             	mov    %eax,(%esp)
    2215:	e8 9a 0b 00 00       	call   2db4 <close>
    221a:	c7 04 24 e9 3b 00 00 	movl   $0x3be9,(%esp)
    2221:	e8 b6 0b 00 00       	call   2ddc <unlink>
    2226:	81 ff 10 27 00 00    	cmp    $0x2710,%edi
    222c:	74 4c                	je     227a <sharedfd+0x18a>
    222e:	b8 ff 3b 00 00       	mov    $0x3bff,%eax
    2233:	89 5c 24 0c          	mov    %ebx,0xc(%esp)
    2237:	89 7c 24 08          	mov    %edi,0x8(%esp)
    223b:	89 44 24 04          	mov    %eax,0x4(%esp)
    223f:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2246:	e8 a5 0c 00 00       	call   2ef0 <printf>
    224b:	83 c4 2c             	add    $0x2c,%esp
    224e:	5b                   	pop    %ebx
    224f:	5e                   	pop    %esi
    2250:	5f                   	pop    %edi
    2251:	5d                   	pop    %ebp
    2252:	c3                   	ret    
    2253:	b8 63 00 00 00       	mov    $0x63,%eax
    2258:	e9 df fe ff ff       	jmp    213c <sharedfd+0x4c>
    225d:	bf 10 43 00 00       	mov    $0x4310,%edi
    2262:	89 7c 24 04          	mov    %edi,0x4(%esp)
    2266:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    226d:	e8 7e 0c 00 00       	call   2ef0 <printf>
    2272:	83 c4 2c             	add    $0x2c,%esp
    2275:	5b                   	pop    %ebx
    2276:	5e                   	pop    %esi
    2277:	5f                   	pop    %edi
    2278:	5d                   	pop    %ebp
    2279:	c3                   	ret    
    227a:	81 fb 10 27 00 00    	cmp    $0x2710,%ebx
    2280:	75 ac                	jne    222e <sharedfd+0x13e>
    2282:	b8 f2 3b 00 00       	mov    $0x3bf2,%eax
    2287:	89 44 24 04          	mov    %eax,0x4(%esp)
    228b:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2292:	e8 59 0c 00 00       	call   2ef0 <printf>
    2297:	eb b2                	jmp    224b <sharedfd+0x15b>
    2299:	b8 5c 43 00 00       	mov    $0x435c,%eax
    229e:	89 44 24 04          	mov    %eax,0x4(%esp)
    22a2:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    22a9:	e8 42 0c 00 00       	call   2ef0 <printf>
    22ae:	83 c4 2c             	add    $0x2c,%esp
    22b1:	5b                   	pop    %ebx
    22b2:	5e                   	pop    %esi
    22b3:	5f                   	pop    %edi
    22b4:	5d                   	pop    %ebp
    22b5:	c3                   	ret    
    22b6:	e8 d1 0a 00 00       	call   2d8c <exit>
    22bb:	90                   	nop    
    22bc:	8d 74 26 00          	lea    0x0(%esi),%esi

000022c0 <writetest1>:
    22c0:	55                   	push   %ebp
    22c1:	89 e5                	mov    %esp,%ebp
    22c3:	56                   	push   %esi
    22c4:	53                   	push   %ebx
    22c5:	bb 14 3c 00 00       	mov    $0x3c14,%ebx
    22ca:	83 ec 10             	sub    $0x10,%esp
    22cd:	a1 54 44 00 00       	mov    0x4454,%eax
    22d2:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    22d6:	31 db                	xor    %ebx,%ebx
    22d8:	89 04 24             	mov    %eax,(%esp)
    22db:	e8 10 0c 00 00       	call   2ef0 <printf>
    22e0:	b9 02 02 00 00       	mov    $0x202,%ecx
    22e5:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    22e9:	c7 04 24 8e 3c 00 00 	movl   $0x3c8e,(%esp)
    22f0:	e8 d7 0a 00 00       	call   2dcc <open>
    22f5:	85 c0                	test   %eax,%eax
    22f7:	89 c6                	mov    %eax,%esi
    22f9:	0f 88 3b 01 00 00    	js     243a <writetest1+0x17a>
    22ff:	90                   	nop    
    2300:	b8 00 02 00 00       	mov    $0x200,%eax
    2305:	89 44 24 08          	mov    %eax,0x8(%esp)
    2309:	b8 80 44 00 00       	mov    $0x4480,%eax
    230e:	89 1d 80 44 00 00    	mov    %ebx,0x4480
    2314:	89 44 24 04          	mov    %eax,0x4(%esp)
    2318:	89 34 24             	mov    %esi,(%esp)
    231b:	e8 8c 0a 00 00       	call   2dac <write>
    2320:	3d 00 02 00 00       	cmp    $0x200,%eax
    2325:	0f 85 e9 00 00 00    	jne    2414 <writetest1+0x154>
    232b:	43                   	inc    %ebx
    232c:	81 fb 8c 00 00 00    	cmp    $0x8c,%ebx
    2332:	75 cc                	jne    2300 <writetest1+0x40>
    2334:	89 34 24             	mov    %esi,(%esp)
    2337:	31 db                	xor    %ebx,%ebx
    2339:	e8 76 0a 00 00       	call   2db4 <close>
    233e:	31 c0                	xor    %eax,%eax
    2340:	89 44 24 04          	mov    %eax,0x4(%esp)
    2344:	c7 04 24 8e 3c 00 00 	movl   $0x3c8e,(%esp)
    234b:	e8 7c 0a 00 00       	call   2dcc <open>
    2350:	89 c6                	mov    %eax,%esi
    2352:	b8 5c 3c 00 00       	mov    $0x3c5c,%eax
    2357:	85 f6                	test   %esi,%esi
    2359:	79 18                	jns    2373 <writetest1+0xb3>
    235b:	e9 c4 00 00 00       	jmp    2424 <writetest1+0x164>
    2360:	3d 00 02 00 00       	cmp    $0x200,%eax
    2365:	75 6b                	jne    23d2 <writetest1+0x112>
    2367:	a1 80 44 00 00       	mov    0x4480,%eax
    236c:	39 c3                	cmp    %eax,%ebx
    236e:	89 f6                	mov    %esi,%esi
    2370:	75 7f                	jne    23f1 <writetest1+0x131>
    2372:	43                   	inc    %ebx
    2373:	b8 00 02 00 00       	mov    $0x200,%eax
    2378:	b9 80 44 00 00       	mov    $0x4480,%ecx
    237d:	89 44 24 08          	mov    %eax,0x8(%esp)
    2381:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    2385:	89 34 24             	mov    %esi,(%esp)
    2388:	e8 17 0a 00 00       	call   2da4 <read>
    238d:	85 c0                	test   %eax,%eax
    238f:	75 cf                	jne    2360 <writetest1+0xa0>
    2391:	81 fb 8b 00 00 00    	cmp    $0x8b,%ebx
    2397:	0f 84 b8 00 00 00    	je     2455 <writetest1+0x195>
    239d:	89 34 24             	mov    %esi,(%esp)
    23a0:	e8 0f 0a 00 00       	call   2db4 <close>
    23a5:	c7 04 24 8e 3c 00 00 	movl   $0x3c8e,(%esp)
    23ac:	e8 2b 0a 00 00       	call   2ddc <unlink>
    23b1:	85 c0                	test   %eax,%eax
    23b3:	78 6a                	js     241f <writetest1+0x15f>
    23b5:	b8 b5 3c 00 00       	mov    $0x3cb5,%eax
    23ba:	89 44 24 04          	mov    %eax,0x4(%esp)
    23be:	a1 54 44 00 00       	mov    0x4454,%eax
    23c3:	89 04 24             	mov    %eax,(%esp)
    23c6:	e8 25 0b 00 00       	call   2ef0 <printf>
    23cb:	83 c4 10             	add    $0x10,%esp
    23ce:	5b                   	pop    %ebx
    23cf:	5e                   	pop    %esi
    23d0:	5d                   	pop    %ebp
    23d1:	c3                   	ret    
    23d2:	89 44 24 08          	mov    %eax,0x8(%esp)
    23d6:	b8 92 3c 00 00       	mov    $0x3c92,%eax
    23db:	89 44 24 04          	mov    %eax,0x4(%esp)
    23df:	a1 54 44 00 00       	mov    0x4454,%eax
    23e4:	89 04 24             	mov    %eax,(%esp)
    23e7:	e8 04 0b 00 00       	call   2ef0 <printf>
    23ec:	e8 9b 09 00 00       	call   2d8c <exit>
    23f1:	89 44 24 0c          	mov    %eax,0xc(%esp)
    23f5:	b8 88 43 00 00       	mov    $0x4388,%eax
    23fa:	89 44 24 04          	mov    %eax,0x4(%esp)
    23fe:	a1 54 44 00 00       	mov    0x4454,%eax
    2403:	89 5c 24 08          	mov    %ebx,0x8(%esp)
    2407:	89 04 24             	mov    %eax,(%esp)
    240a:	e8 e1 0a 00 00       	call   2ef0 <printf>
    240f:	e8 78 09 00 00       	call   2d8c <exit>
    2414:	b8 3e 3c 00 00       	mov    $0x3c3e,%eax
    2419:	89 5c 24 08          	mov    %ebx,0x8(%esp)
    241d:	eb bc                	jmp    23db <writetest1+0x11b>
    241f:	b8 a2 3c 00 00       	mov    $0x3ca2,%eax
    2424:	89 44 24 04          	mov    %eax,0x4(%esp)
    2428:	a1 54 44 00 00       	mov    0x4454,%eax
    242d:	89 04 24             	mov    %eax,(%esp)
    2430:	e8 bb 0a 00 00       	call   2ef0 <printf>
    2435:	e8 52 09 00 00       	call   2d8c <exit>
    243a:	a1 54 44 00 00       	mov    0x4454,%eax
    243f:	ba 24 3c 00 00       	mov    $0x3c24,%edx
    2444:	89 54 24 04          	mov    %edx,0x4(%esp)
    2448:	89 04 24             	mov    %eax,(%esp)
    244b:	e8 a0 0a 00 00       	call   2ef0 <printf>
    2450:	e8 37 09 00 00       	call   2d8c <exit>
    2455:	ba 8b 00 00 00       	mov    $0x8b,%edx
    245a:	b8 75 3c 00 00       	mov    $0x3c75,%eax
    245f:	89 54 24 08          	mov    %edx,0x8(%esp)
    2463:	e9 73 ff ff ff       	jmp    23db <writetest1+0x11b>
    2468:	90                   	nop    
    2469:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00002470 <writetest>:
    2470:	55                   	push   %ebp
    2471:	89 e5                	mov    %esp,%ebp
    2473:	56                   	push   %esi
    2474:	53                   	push   %ebx
    2475:	bb c3 3c 00 00       	mov    $0x3cc3,%ebx
    247a:	83 ec 10             	sub    $0x10,%esp
    247d:	a1 54 44 00 00       	mov    0x4454,%eax
    2482:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    2486:	89 04 24             	mov    %eax,(%esp)
    2489:	e8 62 0a 00 00       	call   2ef0 <printf>
    248e:	b9 02 02 00 00       	mov    $0x202,%ecx
    2493:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    2497:	c7 04 24 d4 3c 00 00 	movl   $0x3cd4,(%esp)
    249e:	e8 29 09 00 00       	call   2dcc <open>
    24a3:	85 c0                	test   %eax,%eax
    24a5:	89 c6                	mov    %eax,%esi
    24a7:	0f 88 58 01 00 00    	js     2605 <writetest+0x195>
    24ad:	a1 54 44 00 00       	mov    0x4454,%eax
    24b2:	ba da 3c 00 00       	mov    $0x3cda,%edx
    24b7:	31 db                	xor    %ebx,%ebx
    24b9:	89 54 24 04          	mov    %edx,0x4(%esp)
    24bd:	89 04 24             	mov    %eax,(%esp)
    24c0:	e8 2b 0a 00 00       	call   2ef0 <printf>
    24c5:	eb 25                	jmp    24ec <writetest+0x7c>
    24c7:	b8 0a 00 00 00       	mov    $0xa,%eax
    24cc:	89 44 24 08          	mov    %eax,0x8(%esp)
    24d0:	b8 1c 3d 00 00       	mov    $0x3d1c,%eax
    24d5:	89 44 24 04          	mov    %eax,0x4(%esp)
    24d9:	89 34 24             	mov    %esi,(%esp)
    24dc:	e8 cb 08 00 00       	call   2dac <write>
    24e1:	83 f8 0a             	cmp    $0xa,%eax
    24e4:	75 44                	jne    252a <writetest+0xba>
    24e6:	43                   	inc    %ebx
    24e7:	83 fb 64             	cmp    $0x64,%ebx
    24ea:	74 5d                	je     2549 <writetest+0xd9>
    24ec:	b8 0a 00 00 00       	mov    $0xa,%eax
    24f1:	89 44 24 08          	mov    %eax,0x8(%esp)
    24f5:	b8 11 3d 00 00       	mov    $0x3d11,%eax
    24fa:	89 44 24 04          	mov    %eax,0x4(%esp)
    24fe:	89 34 24             	mov    %esi,(%esp)
    2501:	e8 a6 08 00 00       	call   2dac <write>
    2506:	83 f8 0a             	cmp    $0xa,%eax
    2509:	74 bc                	je     24c7 <writetest+0x57>
    250b:	b8 a8 43 00 00       	mov    $0x43a8,%eax
    2510:	89 44 24 04          	mov    %eax,0x4(%esp)
    2514:	a1 54 44 00 00       	mov    0x4454,%eax
    2519:	89 5c 24 08          	mov    %ebx,0x8(%esp)
    251d:	89 04 24             	mov    %eax,(%esp)
    2520:	e8 cb 09 00 00       	call   2ef0 <printf>
    2525:	e8 62 08 00 00       	call   2d8c <exit>
    252a:	a1 54 44 00 00       	mov    0x4454,%eax
    252f:	be cc 43 00 00       	mov    $0x43cc,%esi
    2534:	89 5c 24 08          	mov    %ebx,0x8(%esp)
    2538:	89 74 24 04          	mov    %esi,0x4(%esp)
    253c:	89 04 24             	mov    %eax,(%esp)
    253f:	e8 ac 09 00 00       	call   2ef0 <printf>
    2544:	e8 43 08 00 00       	call   2d8c <exit>
    2549:	a1 54 44 00 00       	mov    0x4454,%eax
    254e:	bb 27 3d 00 00       	mov    $0x3d27,%ebx
    2553:	89 5c 24 04          	mov    %ebx,0x4(%esp)
    2557:	89 04 24             	mov    %eax,(%esp)
    255a:	e8 91 09 00 00       	call   2ef0 <printf>
    255f:	89 34 24             	mov    %esi,(%esp)
    2562:	e8 4d 08 00 00       	call   2db4 <close>
    2567:	31 c9                	xor    %ecx,%ecx
    2569:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    256d:	c7 04 24 d4 3c 00 00 	movl   $0x3cd4,(%esp)
    2574:	e8 53 08 00 00       	call   2dcc <open>
    2579:	85 c0                	test   %eax,%eax
    257b:	89 c3                	mov    %eax,%ebx
    257d:	0f 88 9d 00 00 00    	js     2620 <writetest+0x1b0>
    2583:	a1 54 44 00 00       	mov    0x4454,%eax
    2588:	ba 32 3d 00 00       	mov    $0x3d32,%edx
    258d:	89 54 24 04          	mov    %edx,0x4(%esp)
    2591:	89 04 24             	mov    %eax,(%esp)
    2594:	e8 57 09 00 00       	call   2ef0 <printf>
    2599:	b8 d0 07 00 00       	mov    $0x7d0,%eax
    259e:	89 44 24 08          	mov    %eax,0x8(%esp)
    25a2:	b8 80 44 00 00       	mov    $0x4480,%eax
    25a7:	89 44 24 04          	mov    %eax,0x4(%esp)
    25ab:	89 1c 24             	mov    %ebx,(%esp)
    25ae:	e8 f1 07 00 00       	call   2da4 <read>
    25b3:	3d d0 07 00 00       	cmp    $0x7d0,%eax
    25b8:	75 6d                	jne    2627 <writetest+0x1b7>
    25ba:	b8 66 3d 00 00       	mov    $0x3d66,%eax
    25bf:	89 44 24 04          	mov    %eax,0x4(%esp)
    25c3:	a1 54 44 00 00       	mov    0x4454,%eax
    25c8:	89 04 24             	mov    %eax,(%esp)
    25cb:	e8 20 09 00 00       	call   2ef0 <printf>
    25d0:	89 1c 24             	mov    %ebx,(%esp)
    25d3:	e8 dc 07 00 00       	call   2db4 <close>
    25d8:	c7 04 24 d4 3c 00 00 	movl   $0x3cd4,(%esp)
    25df:	e8 f8 07 00 00       	call   2ddc <unlink>
    25e4:	85 c0                	test   %eax,%eax
    25e6:	78 46                	js     262e <writetest+0x1be>
    25e8:	a1 54 44 00 00       	mov    0x4454,%eax
    25ed:	be 8e 3d 00 00       	mov    $0x3d8e,%esi
    25f2:	89 74 24 04          	mov    %esi,0x4(%esp)
    25f6:	89 04 24             	mov    %eax,(%esp)
    25f9:	e8 f2 08 00 00       	call   2ef0 <printf>
    25fe:	83 c4 10             	add    $0x10,%esp
    2601:	5b                   	pop    %ebx
    2602:	5e                   	pop    %esi
    2603:	5d                   	pop    %ebp
    2604:	c3                   	ret    
    2605:	b8 f5 3c 00 00       	mov    $0x3cf5,%eax
    260a:	89 44 24 04          	mov    %eax,0x4(%esp)
    260e:	a1 54 44 00 00       	mov    0x4454,%eax
    2613:	89 04 24             	mov    %eax,(%esp)
    2616:	e8 d5 08 00 00       	call   2ef0 <printf>
    261b:	e8 6c 07 00 00       	call   2d8c <exit>
    2620:	b8 4b 3d 00 00       	mov    $0x3d4b,%eax
    2625:	eb e3                	jmp    260a <writetest+0x19a>
    2627:	b8 06 3b 00 00       	mov    $0x3b06,%eax
    262c:	eb dc                	jmp    260a <writetest+0x19a>
    262e:	b8 79 3d 00 00       	mov    $0x3d79,%eax
    2633:	eb d5                	jmp    260a <writetest+0x19a>
    2635:	8d 74 26 00          	lea    0x0(%esi),%esi
    2639:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00002640 <mem>:
    2640:	55                   	push   %ebp
    2641:	89 e5                	mov    %esp,%ebp
    2643:	56                   	push   %esi
    2644:	31 f6                	xor    %esi,%esi
    2646:	53                   	push   %ebx
    2647:	83 ec 10             	sub    $0x10,%esp
    264a:	e8 35 07 00 00       	call   2d84 <fork>
    264f:	85 c0                	test   %eax,%eax
    2651:	74 06                	je     2659 <mem+0x19>
    2653:	eb 55                	jmp    26aa <mem+0x6a>
    2655:	89 30                	mov    %esi,(%eax)
    2657:	89 c6                	mov    %eax,%esi
    2659:	c7 04 24 11 27 00 00 	movl   $0x2711,(%esp)
    2660:	e8 9b 0a 00 00       	call   3100 <malloc>
    2665:	85 c0                	test   %eax,%eax
    2667:	75 ec                	jne    2655 <mem+0x15>
    2669:	85 f6                	test   %esi,%esi
    266b:	74 13                	je     2680 <mem+0x40>
    266d:	8d 76 00             	lea    0x0(%esi),%esi
    2670:	8b 1e                	mov    (%esi),%ebx
    2672:	89 34 24             	mov    %esi,(%esp)
    2675:	e8 f6 09 00 00       	call   3070 <free>
    267a:	89 de                	mov    %ebx,%esi
    267c:	85 f6                	test   %esi,%esi
    267e:	75 f0                	jne    2670 <mem+0x30>
    2680:	c7 04 24 00 50 00 00 	movl   $0x5000,(%esp)
    2687:	e8 74 0a 00 00       	call   3100 <malloc>
    268c:	85 c0                	test   %eax,%eax
    268e:	75 25                	jne    26b5 <mem+0x75>
    2690:	b8 a2 3d 00 00       	mov    $0x3da2,%eax
    2695:	89 44 24 04          	mov    %eax,0x4(%esp)
    2699:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    26a0:	e8 4b 08 00 00       	call   2ef0 <printf>
    26a5:	e8 e2 06 00 00       	call   2d8c <exit>
    26aa:	83 c4 10             	add    $0x10,%esp
    26ad:	5b                   	pop    %ebx
    26ae:	5e                   	pop    %esi
    26af:	5d                   	pop    %ebp
    26b0:	e9 df 06 00 00       	jmp    2d94 <wait>
    26b5:	be bc 3d 00 00       	mov    $0x3dbc,%esi
    26ba:	89 04 24             	mov    %eax,(%esp)
    26bd:	e8 ae 09 00 00       	call   3070 <free>
    26c2:	89 74 24 04          	mov    %esi,0x4(%esp)
    26c6:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    26cd:	e8 1e 08 00 00       	call   2ef0 <printf>
    26d2:	e8 b5 06 00 00       	call   2d8c <exit>
    26d7:	89 f6                	mov    %esi,%esi
    26d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000026e0 <pipe1>:
    26e0:	55                   	push   %ebp
    26e1:	89 e5                	mov    %esp,%ebp
    26e3:	57                   	push   %edi
    26e4:	56                   	push   %esi
    26e5:	53                   	push   %ebx
    26e6:	83 ec 1c             	sub    $0x1c,%esp
    26e9:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
    26ec:	89 04 24             	mov    %eax,(%esp)
    26ef:	e8 a8 06 00 00       	call   2d9c <pipe>
    26f4:	85 c0                	test   %eax,%eax
    26f6:	0f 85 73 01 00 00    	jne    286f <pipe1+0x18f>
    26fc:	e8 83 06 00 00       	call   2d84 <fork>
    2701:	83 f8 00             	cmp    $0x0,%eax
    2704:	0f 84 8f 00 00 00    	je     2799 <pipe1+0xb9>
    270a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    2710:	0f 8e 73 01 00 00    	jle    2889 <pipe1+0x1a9>
    2716:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    2719:	31 db                	xor    %ebx,%ebx
    271b:	be 01 00 00 00       	mov    $0x1,%esi
    2720:	31 ff                	xor    %edi,%edi
    2722:	89 04 24             	mov    %eax,(%esp)
    2725:	e8 8a 06 00 00       	call   2db4 <close>
    272a:	b8 80 44 00 00       	mov    $0x4480,%eax
    272f:	89 44 24 04          	mov    %eax,0x4(%esp)
    2733:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
    2736:	89 74 24 08          	mov    %esi,0x8(%esp)
    273a:	89 04 24             	mov    %eax,(%esp)
    273d:	e8 62 06 00 00       	call   2da4 <read>
    2742:	85 c0                	test   %eax,%eax
    2744:	0f 8e bd 00 00 00    	jle    2807 <pipe1+0x127>
    274a:	38 1d 80 44 00 00    	cmp    %bl,0x4480
    2750:	75 21                	jne    2773 <pipe1+0x93>
    2752:	43                   	inc    %ebx
    2753:	31 d2                	xor    %edx,%edx
    2755:	eb 09                	jmp    2760 <pipe1+0x80>
    2757:	38 9a 80 44 00 00    	cmp    %bl,0x4480(%edx)
    275d:	75 14                	jne    2773 <pipe1+0x93>
    275f:	43                   	inc    %ebx
    2760:	42                   	inc    %edx
    2761:	39 d0                	cmp    %edx,%eax
    2763:	75 f2                	jne    2757 <pipe1+0x77>
    2765:	01 f6                	add    %esi,%esi
    2767:	81 fe 00 08 00 00    	cmp    $0x800,%esi
    276d:	77 21                	ja     2790 <pipe1+0xb0>
    276f:	01 d7                	add    %edx,%edi
    2771:	eb b7                	jmp    272a <pipe1+0x4a>
    2773:	b8 e1 3d 00 00       	mov    $0x3de1,%eax
    2778:	89 44 24 04          	mov    %eax,0x4(%esp)
    277c:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2783:	e8 68 07 00 00       	call   2ef0 <printf>
    2788:	83 c4 1c             	add    $0x1c,%esp
    278b:	5b                   	pop    %ebx
    278c:	5e                   	pop    %esi
    278d:	5f                   	pop    %edi
    278e:	5d                   	pop    %ebp
    278f:	c3                   	ret    
    2790:	be 00 08 00 00       	mov    $0x800,%esi
    2795:	01 d7                	add    %edx,%edi
    2797:	eb 91                	jmp    272a <pipe1+0x4a>
    2799:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
    279c:	31 db                	xor    %ebx,%ebx
    279e:	89 04 24             	mov    %eax,(%esp)
    27a1:	e8 0e 06 00 00       	call   2db4 <close>
    27a6:	8d 76 00             	lea    0x0(%esi),%esi
    27a9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi
    27b0:	88 da                	mov    %bl,%dl
    27b2:	31 c0                	xor    %eax,%eax
    27b4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    27ba:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi
    27c0:	88 90 80 44 00 00    	mov    %dl,0x4480(%eax)
    27c6:	40                   	inc    %eax
    27c7:	fe c2                	inc    %dl
    27c9:	3d 09 04 00 00       	cmp    $0x409,%eax
    27ce:	75 f0                	jne    27c0 <pipe1+0xe0>
    27d0:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    27d3:	b9 80 44 00 00       	mov    $0x4480,%ecx
    27d8:	be 09 04 00 00       	mov    $0x409,%esi
    27dd:	89 74 24 08          	mov    %esi,0x8(%esp)
    27e1:	81 c3 09 04 00 00    	add    $0x409,%ebx
    27e7:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    27eb:	89 04 24             	mov    %eax,(%esp)
    27ee:	e8 b9 05 00 00       	call   2dac <write>
    27f3:	3d 09 04 00 00       	cmp    $0x409,%eax
    27f8:	75 5b                	jne    2855 <pipe1+0x175>
    27fa:	81 fb 2d 14 00 00    	cmp    $0x142d,%ebx
    2800:	75 ae                	jne    27b0 <pipe1+0xd0>
    2802:	e8 85 05 00 00       	call   2d8c <exit>
    2807:	81 ff 2d 14 00 00    	cmp    $0x142d,%edi
    280d:	8d 76 00             	lea    0x0(%esi),%esi
    2810:	74 19                	je     282b <pipe1+0x14b>
    2812:	b8 ef 3d 00 00       	mov    $0x3def,%eax
    2817:	89 7c 24 08          	mov    %edi,0x8(%esp)
    281b:	89 44 24 04          	mov    %eax,0x4(%esp)
    281f:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2826:	e8 c5 06 00 00       	call   2ef0 <printf>
    282b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
    282e:	89 04 24             	mov    %eax,(%esp)
    2831:	e8 7e 05 00 00       	call   2db4 <close>
    2836:	e8 59 05 00 00       	call   2d94 <wait>
    283b:	b8 06 3e 00 00       	mov    $0x3e06,%eax
    2840:	89 44 24 04          	mov    %eax,0x4(%esp)
    2844:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    284b:	e8 a0 06 00 00       	call   2ef0 <printf>
    2850:	e9 33 ff ff ff       	jmp    2788 <pipe1+0xa8>
    2855:	ba d3 3d 00 00       	mov    $0x3dd3,%edx
    285a:	89 54 24 04          	mov    %edx,0x4(%esp)
    285e:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2865:	e8 86 06 00 00       	call   2ef0 <printf>
    286a:	e8 1d 05 00 00       	call   2d8c <exit>
    286f:	bf c4 3d 00 00       	mov    $0x3dc4,%edi
    2874:	89 7c 24 04          	mov    %edi,0x4(%esp)
    2878:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    287f:	e8 6c 06 00 00       	call   2ef0 <printf>
    2884:	e8 03 05 00 00       	call   2d8c <exit>
    2889:	b8 10 3e 00 00       	mov    $0x3e10,%eax
    288e:	89 44 24 04          	mov    %eax,0x4(%esp)
    2892:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2899:	e8 52 06 00 00       	call   2ef0 <printf>
    289e:	e9 5f ff ff ff       	jmp    2802 <pipe1+0x122>
    28a3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    28a9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

000028b0 <preempt>:
    28b0:	55                   	push   %ebp
    28b1:	89 e5                	mov    %esp,%ebp
    28b3:	57                   	push   %edi
    28b4:	56                   	push   %esi
    28b5:	be 1f 3e 00 00       	mov    $0x3e1f,%esi
    28ba:	53                   	push   %ebx
    28bb:	83 ec 1c             	sub    $0x1c,%esp
    28be:	89 74 24 04          	mov    %esi,0x4(%esp)
    28c2:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    28c9:	e8 22 06 00 00       	call   2ef0 <printf>
    28ce:	e8 b1 04 00 00       	call   2d84 <fork>
    28d3:	85 c0                	test   %eax,%eax
    28d5:	89 c7                	mov    %eax,%edi
    28d7:	75 02                	jne    28db <preempt+0x2b>
    28d9:	eb fe                	jmp    28d9 <preempt+0x29>
    28db:	90                   	nop    
    28dc:	8d 74 26 00          	lea    0x0(%esi),%esi
    28e0:	e8 9f 04 00 00       	call   2d84 <fork>
    28e5:	85 c0                	test   %eax,%eax
    28e7:	89 c6                	mov    %eax,%esi
    28e9:	75 02                	jne    28ed <preempt+0x3d>
    28eb:	eb fe                	jmp    28eb <preempt+0x3b>
    28ed:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
    28f0:	89 04 24             	mov    %eax,(%esp)
    28f3:	e8 a4 04 00 00       	call   2d9c <pipe>
    28f8:	e8 87 04 00 00       	call   2d84 <fork>
    28fd:	85 c0                	test   %eax,%eax
    28ff:	89 c3                	mov    %eax,%ebx
    2901:	75 4d                	jne    2950 <preempt+0xa0>
    2903:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
    2906:	bb 01 00 00 00       	mov    $0x1,%ebx
    290b:	89 04 24             	mov    %eax,(%esp)
    290e:	e8 a1 04 00 00       	call   2db4 <close>
    2913:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    2916:	b9 ab 38 00 00       	mov    $0x38ab,%ecx
    291b:	89 5c 24 08          	mov    %ebx,0x8(%esp)
    291f:	89 4c 24 04          	mov    %ecx,0x4(%esp)
    2923:	89 04 24             	mov    %eax,(%esp)
    2926:	e8 81 04 00 00       	call   2dac <write>
    292b:	48                   	dec    %eax
    292c:	74 15                	je     2943 <preempt+0x93>
    292e:	ba 29 3e 00 00       	mov    $0x3e29,%edx
    2933:	89 54 24 04          	mov    %edx,0x4(%esp)
    2937:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    293e:	e8 ad 05 00 00       	call   2ef0 <printf>
    2943:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    2946:	89 04 24             	mov    %eax,(%esp)
    2949:	e8 66 04 00 00       	call   2db4 <close>
    294e:	eb fe                	jmp    294e <preempt+0x9e>
    2950:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    2953:	89 04 24             	mov    %eax,(%esp)
    2956:	e8 59 04 00 00       	call   2db4 <close>
    295b:	b8 00 08 00 00       	mov    $0x800,%eax
    2960:	89 44 24 08          	mov    %eax,0x8(%esp)
    2964:	b8 80 44 00 00       	mov    $0x4480,%eax
    2969:	89 44 24 04          	mov    %eax,0x4(%esp)
    296d:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
    2970:	89 04 24             	mov    %eax,(%esp)
    2973:	e8 2c 04 00 00       	call   2da4 <read>
    2978:	48                   	dec    %eax
    2979:	74 1d                	je     2998 <preempt+0xe8>
    297b:	b8 3d 3e 00 00       	mov    $0x3e3d,%eax
    2980:	89 44 24 04          	mov    %eax,0x4(%esp)
    2984:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    298b:	e8 60 05 00 00       	call   2ef0 <printf>
    2990:	83 c4 1c             	add    $0x1c,%esp
    2993:	5b                   	pop    %ebx
    2994:	5e                   	pop    %esi
    2995:	5f                   	pop    %edi
    2996:	5d                   	pop    %ebp
    2997:	c3                   	ret    
    2998:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
    299b:	89 04 24             	mov    %eax,(%esp)
    299e:	e8 11 04 00 00       	call   2db4 <close>
    29a3:	b8 50 3e 00 00       	mov    $0x3e50,%eax
    29a8:	89 44 24 04          	mov    %eax,0x4(%esp)
    29ac:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    29b3:	e8 38 05 00 00       	call   2ef0 <printf>
    29b8:	89 3c 24             	mov    %edi,(%esp)
    29bb:	e8 fc 03 00 00       	call   2dbc <kill>
    29c0:	89 34 24             	mov    %esi,(%esp)
    29c3:	e8 f4 03 00 00       	call   2dbc <kill>
    29c8:	89 1c 24             	mov    %ebx,(%esp)
    29cb:	e8 ec 03 00 00       	call   2dbc <kill>
    29d0:	b8 59 3e 00 00       	mov    $0x3e59,%eax
    29d5:	89 44 24 04          	mov    %eax,0x4(%esp)
    29d9:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    29e0:	e8 0b 05 00 00       	call   2ef0 <printf>
    29e5:	e8 aa 03 00 00       	call   2d94 <wait>
    29ea:	e8 a5 03 00 00       	call   2d94 <wait>
    29ef:	90                   	nop    
    29f0:	e8 9f 03 00 00       	call   2d94 <wait>
    29f5:	b8 62 3e 00 00       	mov    $0x3e62,%eax
    29fa:	89 44 24 04          	mov    %eax,0x4(%esp)
    29fe:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2a05:	e8 e6 04 00 00       	call   2ef0 <printf>
    2a0a:	eb 84                	jmp    2990 <preempt+0xe0>
    2a0c:	8d 74 26 00          	lea    0x0(%esi),%esi

00002a10 <exectest>:
    2a10:	55                   	push   %ebp
    2a11:	b8 6e 3e 00 00       	mov    $0x3e6e,%eax
    2a16:	89 e5                	mov    %esp,%ebp
    2a18:	83 ec 08             	sub    $0x8,%esp
    2a1b:	89 44 24 04          	mov    %eax,0x4(%esp)
    2a1f:	a1 54 44 00 00       	mov    0x4454,%eax
    2a24:	89 04 24             	mov    %eax,(%esp)
    2a27:	e8 c4 04 00 00       	call   2ef0 <printf>
    2a2c:	b8 34 44 00 00       	mov    $0x4434,%eax
    2a31:	89 44 24 04          	mov    %eax,0x4(%esp)
    2a35:	c7 04 24 e7 31 00 00 	movl   $0x31e7,(%esp)
    2a3c:	e8 83 03 00 00       	call   2dc4 <exec>
    2a41:	85 c0                	test   %eax,%eax
    2a43:	78 02                	js     2a47 <exectest+0x37>
    2a45:	c9                   	leave  
    2a46:	c3                   	ret    
    2a47:	b8 79 3e 00 00       	mov    $0x3e79,%eax
    2a4c:	89 44 24 04          	mov    %eax,0x4(%esp)
    2a50:	a1 54 44 00 00       	mov    0x4454,%eax
    2a55:	89 04 24             	mov    %eax,(%esp)
    2a58:	e8 93 04 00 00       	call   2ef0 <printf>
    2a5d:	e8 2a 03 00 00       	call   2d8c <exit>
    2a62:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
    2a69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00002a70 <main>:

int
main(int argc, char *argv[])
{
    2a70:	8d 4c 24 04          	lea    0x4(%esp),%ecx
    2a74:	83 e4 f0             	and    $0xfffffff0,%esp
    2a77:	ff 71 fc             	pushl  0xfffffffc(%ecx)
  printf(1, "usertests starting\n");
    2a7a:	ba 8b 3e 00 00       	mov    $0x3e8b,%edx
    2a7f:	55                   	push   %ebp
    2a80:	89 e5                	mov    %esp,%ebp
    2a82:	51                   	push   %ecx
    2a83:	83 ec 14             	sub    $0x14,%esp
    2a86:	89 54 24 04          	mov    %edx,0x4(%esp)
    2a8a:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2a91:	e8 5a 04 00 00       	call   2ef0 <printf>

  if(open("usertests.ran", 0) >= 0){
    2a96:	31 c0                	xor    %eax,%eax
    2a98:	89 44 24 04          	mov    %eax,0x4(%esp)
    2a9c:	c7 04 24 9f 3e 00 00 	movl   $0x3e9f,(%esp)
    2aa3:	e8 24 03 00 00       	call   2dcc <open>
    2aa8:	85 c0                	test   %eax,%eax
    2aaa:	78 1a                	js     2ac6 <main+0x56>
    printf(1, "already ran user tests -- rebuild fs.img\n");
    2aac:	b8 f0 43 00 00       	mov    $0x43f0,%eax
    2ab1:	89 44 24 04          	mov    %eax,0x4(%esp)
    2ab5:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    2abc:	e8 2f 04 00 00       	call   2ef0 <printf>
    exit();
    2ac1:	e8 c6 02 00 00       	call   2d8c <exit>
  }
  close(open("usertests.ran", O_CREATE));
    2ac6:	b8 00 02 00 00       	mov    $0x200,%eax
    2acb:	89 44 24 04          	mov    %eax,0x4(%esp)
    2acf:	c7 04 24 9f 3e 00 00 	movl   $0x3e9f,(%esp)
    2ad6:	e8 f1 02 00 00       	call   2dcc <open>
    2adb:	89 04 24             	mov    %eax,(%esp)
    2ade:	e8 d1 02 00 00       	call   2db4 <close>

  opentest();
    2ae3:	e8 18 d5 ff ff       	call   0 <opentest>
  writetest();
    2ae8:	e8 83 f9 ff ff       	call   2470 <writetest>
    2aed:	8d 76 00             	lea    0x0(%esi),%esi
  writetest1();
    2af0:	e8 cb f7 ff ff       	call   22c0 <writetest1>
  createtest();
    2af5:	e8 d6 df ff ff       	call   ad0 <createtest>

  mem();
    2afa:	e8 41 fb ff ff       	call   2640 <mem>
    2aff:	90                   	nop    
  pipe1();
    2b00:	e8 db fb ff ff       	call   26e0 <pipe1>
  preempt();
    2b05:	e8 a6 fd ff ff       	call   28b0 <preempt>
  exitwait();
    2b0a:	e8 61 d6 ff ff       	call   170 <exitwait>
    2b0f:	90                   	nop    

  rmdot();
    2b10:	e8 7b d9 ff ff       	call   490 <rmdot>
  fourteen();
    2b15:	e8 e6 d6 ff ff       	call   200 <fourteen>
  bigfile();
    2b1a:	e8 b1 e2 ff ff       	call   dd0 <bigfile>
    2b1f:	90                   	nop    
  subdir();
    2b20:	e8 bb e4 ff ff       	call   fe0 <subdir>
  concreate();
    2b25:	e8 66 ec ff ff       	call   1790 <concreate>
  linktest();
    2b2a:	e8 21 ef ff ff       	call   1a50 <linktest>
    2b2f:	90                   	nop    
  unlinkread();
    2b30:	e8 8b f1 ff ff       	call   1cc0 <unlinkread>
  createdelete();
    2b35:	e8 66 dc ff ff       	call   7a0 <createdelete>
  twofiles();
    2b3a:	e8 71 f3 ff ff       	call   1eb0 <twofiles>
    2b3f:	90                   	nop    
  sharedfd();
    2b40:	e8 ab f5 ff ff       	call   20f0 <sharedfd>
  dirfile();
    2b45:	e8 36 e0 ff ff       	call   b80 <dirfile>
  iref();
    2b4a:	e8 21 d8 ff ff       	call   370 <iref>
    2b4f:	90                   	nop    
  forktest();
    2b50:	e8 4b d5 ff ff       	call   a0 <forktest>
  bigdir(); // slow
    2b55:	e8 e6 da ff ff       	call   640 <bigdir>

  exectest();
    2b5a:	e8 b1 fe ff ff       	call   2a10 <exectest>
    2b5f:	90                   	nop    

  exit();
    2b60:	e8 27 02 00 00       	call   2d8c <exit>
    2b65:	90                   	nop    
    2b66:	90                   	nop    
    2b67:	90                   	nop    
    2b68:	90                   	nop    
    2b69:	90                   	nop    
    2b6a:	90                   	nop    
    2b6b:	90                   	nop    
    2b6c:	90                   	nop    
    2b6d:	90                   	nop    
    2b6e:	90                   	nop    
    2b6f:	90                   	nop    

00002b70 <strcpy>:
#include "user.h"

char*
strcpy(char *s, char *t)
{
    2b70:	55                   	push   %ebp
    2b71:	89 e5                	mov    %esp,%ebp
    2b73:	53                   	push   %ebx
    2b74:	8b 5d 08             	mov    0x8(%ebp),%ebx
    2b77:	8b 4d 0c             	mov    0xc(%ebp),%ecx
    2b7a:	89 da                	mov    %ebx,%edx
    2b7c:	8d 74 26 00          	lea    0x0(%esi),%esi
  char *os;

  os = s;
  while((*s++ = *t++) != 0)
    2b80:	0f b6 01             	movzbl (%ecx),%eax
    2b83:	41                   	inc    %ecx
    2b84:	88 02                	mov    %al,(%edx)
    2b86:	42                   	inc    %edx
    2b87:	84 c0                	test   %al,%al
    2b89:	75 f5                	jne    2b80 <strcpy+0x10>
    ;
  return os;
}
    2b8b:	89 d8                	mov    %ebx,%eax
    2b8d:	5b                   	pop    %ebx
    2b8e:	5d                   	pop    %ebp
    2b8f:	c3                   	ret    

00002b90 <strcmp>:

int
strcmp(const char *p, const char *q)
{
    2b90:	55                   	push   %ebp
    2b91:	89 e5                	mov    %esp,%ebp
    2b93:	8b 55 08             	mov    0x8(%ebp),%edx
    2b96:	8b 4d 0c             	mov    0xc(%ebp),%ecx
  while(*p && *p == *q)
    2b99:	0f b6 02             	movzbl (%edx),%eax
    2b9c:	84 c0                	test   %al,%al
    2b9e:	75 0c                	jne    2bac <strcmp+0x1c>
    2ba0:	eb 10                	jmp    2bb2 <strcmp+0x22>
    2ba2:	0f b6 42 01          	movzbl 0x1(%edx),%eax
    p++, q++;
    2ba6:	41                   	inc    %ecx
    2ba7:	84 c0                	test   %al,%al
    2ba9:	74 07                	je     2bb2 <strcmp+0x22>
    2bab:	42                   	inc    %edx
    2bac:	3a 01                	cmp    (%ecx),%al
    2bae:	89 f6                	mov    %esi,%esi
    2bb0:	74 f0                	je     2ba2 <strcmp+0x12>
    2bb2:	0f b6 11             	movzbl (%ecx),%edx
    2bb5:	0f b6 c0             	movzbl %al,%eax
  return (uchar)*p - (uchar)*q;
}
    2bb8:	5d                   	pop    %ebp
    2bb9:	29 d0                	sub    %edx,%eax
    2bbb:	c3                   	ret    
    2bbc:	8d 74 26 00          	lea    0x0(%esi),%esi

00002bc0 <strlen>:

uint
strlen(char *s)
{
    2bc0:	55                   	push   %ebp
  int n;

  for(n = 0; s[n]; n++)
    2bc1:	31 c0                	xor    %eax,%eax
    2bc3:	89 e5                	mov    %esp,%ebp
    2bc5:	8b 55 08             	mov    0x8(%ebp),%edx
    2bc8:	80 3a 00             	cmpb   $0x0,(%edx)
    2bcb:	74 0a                	je     2bd7 <strlen+0x17>
    2bcd:	8d 76 00             	lea    0x0(%esi),%esi
    2bd0:	40                   	inc    %eax
    2bd1:	80 3c 10 00          	cmpb   $0x0,(%eax,%edx,1)
    2bd5:	75 f9                	jne    2bd0 <strlen+0x10>
    ;
  return n;
}
    2bd7:	5d                   	pop    %ebp
    2bd8:	c3                   	ret    
    2bd9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00002be0 <memset>:

void*
memset(void *dst, int c, uint n)
{
    2be0:	55                   	push   %ebp
    2be1:	89 e5                	mov    %esp,%ebp
    2be3:	8b 45 10             	mov    0x10(%ebp),%eax
    2be6:	53                   	push   %ebx
    2be7:	8b 5d 08             	mov    0x8(%ebp),%ebx
  char *d;
  
  d = dst;
  while(n-- > 0)
    2bea:	85 c0                	test   %eax,%eax
    2bec:	74 1a                	je     2c08 <memset+0x28>
    2bee:	0f b6 4d 0c          	movzbl 0xc(%ebp),%ecx
    2bf2:	31 d2                	xor    %edx,%edx
    2bf4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    2bfa:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi
    *d++ = c;
    2c00:	88 0c 1a             	mov    %cl,(%edx,%ebx,1)
    2c03:	42                   	inc    %edx
    2c04:	39 d0                	cmp    %edx,%eax
    2c06:	75 f8                	jne    2c00 <memset+0x20>
  return dst;
}
    2c08:	89 d8                	mov    %ebx,%eax
    2c0a:	5b                   	pop    %ebx
    2c0b:	5d                   	pop    %ebp
    2c0c:	c3                   	ret    
    2c0d:	8d 76 00             	lea    0x0(%esi),%esi

00002c10 <strchr>:

char*
strchr(const char *s, char c)
{
    2c10:	55                   	push   %ebp
    2c11:	89 e5                	mov    %esp,%ebp
    2c13:	8b 45 08             	mov    0x8(%ebp),%eax
    2c16:	0f b6 4d 0c          	movzbl 0xc(%ebp),%ecx
  for(; *s; s++)
    2c1a:	0f b6 10             	movzbl (%eax),%edx
    2c1d:	84 d2                	test   %dl,%dl
    2c1f:	74 19                	je     2c3a <strchr+0x2a>
    if(*s == c)
    2c21:	38 d1                	cmp    %dl,%cl
    2c23:	75 0d                	jne    2c32 <strchr+0x22>
    2c25:	eb 15                	jmp    2c3c <strchr+0x2c>
    2c27:	38 ca                	cmp    %cl,%dl
    2c29:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
    2c30:	74 0a                	je     2c3c <strchr+0x2c>
    2c32:	40                   	inc    %eax
    2c33:	0f b6 10             	movzbl (%eax),%edx
    2c36:	84 d2                	test   %dl,%dl
    2c38:	75 ed                	jne    2c27 <strchr+0x17>
    2c3a:	31 c0                	xor    %eax,%eax
      return (char*) s;
  return 0;
}
    2c3c:	5d                   	pop    %ebp
    2c3d:	c3                   	ret    
    2c3e:	89 f6                	mov    %esi,%esi

00002c40 <atoi>:

char*
gets(char *buf, int max)
{
  int i, cc;
  char c;

  for(i=0; i+1 < max; ){
    cc = read(0, &c, 1);
    if(cc < 1)
      break;
    buf[i++] = c;
    if(c == '\n' || c == '\r')
      break;
  }
  buf[i] = '\0';
  return buf;
}

int
stat(char *n, struct stat *st)
{
  int fd;
  int r;

  fd = open(n, O_RDONLY);
  if(fd < 0)
    return -1;
  r = fstat(fd, st);
  close(fd);
  return r;
}

int
atoi(const char *s)
{
    2c40:	55                   	push   %ebp
    2c41:	89 e5                	mov    %esp,%ebp
    2c43:	8b 4d 08             	mov    0x8(%ebp),%ecx
    2c46:	53                   	push   %ebx
  int n;

  n = 0;
  while('0' <= *s && *s <= '9')
    2c47:	31 db                	xor    %ebx,%ebx
    2c49:	0f b6 11             	movzbl (%ecx),%edx
    2c4c:	88 d0                	mov    %dl,%al
    2c4e:	2c 30                	sub    $0x30,%al
    2c50:	3c 09                	cmp    $0x9,%al
    2c52:	77 23                	ja     2c77 <atoi+0x37>
    2c54:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    2c5a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi
    n = n*10 + *s++ - '0';
    2c60:	8d 04 9b             	lea    (%ebx,%ebx,4),%eax
    2c63:	0f be d2             	movsbl %dl,%edx
    2c66:	8d 5c 42 d0          	lea    0xffffffd0(%edx,%eax,2),%ebx
    2c6a:	0f b6 51 01          	movzbl 0x1(%ecx),%edx
    2c6e:	41                   	inc    %ecx
    2c6f:	88 d0                	mov    %dl,%al
    2c71:	2c 30                	sub    $0x30,%al
    2c73:	3c 09                	cmp    $0x9,%al
    2c75:	76 e9                	jbe    2c60 <atoi+0x20>
  return n;
}
    2c77:	89 d8                	mov    %ebx,%eax
    2c79:	5b                   	pop    %ebx
    2c7a:	5d                   	pop    %ebp
    2c7b:	c3                   	ret    
    2c7c:	8d 74 26 00          	lea    0x0(%esi),%esi

00002c80 <memmove>:

void*
memmove(void *vdst, void *vsrc, int n)
{
    2c80:	55                   	push   %ebp
    2c81:	89 e5                	mov    %esp,%ebp
    2c83:	8b 4d 10             	mov    0x10(%ebp),%ecx
    2c86:	56                   	push   %esi
    2c87:	8b 75 08             	mov    0x8(%ebp),%esi
    2c8a:	53                   	push   %ebx
    2c8b:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  char *dst, *src;
  
  dst = vdst;
  src = vsrc;
  while(n-- > 0)
    2c8e:	85 c9                	test   %ecx,%ecx
    2c90:	7e 1a                	jle    2cac <memmove+0x2c>
    2c92:	31 d2                	xor    %edx,%edx
    2c94:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    2c9a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi
    *dst++ = *src++;
    2ca0:	0f b6 04 1a          	movzbl (%edx,%ebx,1),%eax
    2ca4:	88 04 32             	mov    %al,(%edx,%esi,1)
    2ca7:	42                   	inc    %edx
    2ca8:	39 ca                	cmp    %ecx,%edx
    2caa:	75 f4                	jne    2ca0 <memmove+0x20>
  return vdst;
}
    2cac:	5b                   	pop    %ebx
    2cad:	89 f0                	mov    %esi,%eax
    2caf:	5e                   	pop    %esi
    2cb0:	5d                   	pop    %ebp
    2cb1:	c3                   	ret    
    2cb2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
    2cb9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00002cc0 <stat>:
    2cc0:	55                   	push   %ebp
    2cc1:	31 c0                	xor    %eax,%eax
    2cc3:	89 e5                	mov    %esp,%ebp
    2cc5:	83 ec 18             	sub    $0x18,%esp
    2cc8:	89 44 24 04          	mov    %eax,0x4(%esp)
    2ccc:	8b 45 08             	mov    0x8(%ebp),%eax
    2ccf:	89 5d f8             	mov    %ebx,0xfffffff8(%ebp)
    2cd2:	89 75 fc             	mov    %esi,0xfffffffc(%ebp)
    2cd5:	be ff ff ff ff       	mov    $0xffffffff,%esi
    2cda:	89 04 24             	mov    %eax,(%esp)
    2cdd:	e8 ea 00 00 00       	call   2dcc <open>
    2ce2:	85 c0                	test   %eax,%eax
    2ce4:	89 c3                	mov    %eax,%ebx
    2ce6:	78 19                	js     2d01 <stat+0x41>
    2ce8:	8b 45 0c             	mov    0xc(%ebp),%eax
    2ceb:	89 1c 24             	mov    %ebx,(%esp)
    2cee:	89 44 24 04          	mov    %eax,0x4(%esp)
    2cf2:	e8 ed 00 00 00       	call   2de4 <fstat>
    2cf7:	89 1c 24             	mov    %ebx,(%esp)
    2cfa:	89 c6                	mov    %eax,%esi
    2cfc:	e8 b3 00 00 00       	call   2db4 <close>
    2d01:	89 f0                	mov    %esi,%eax
    2d03:	8b 5d f8             	mov    0xfffffff8(%ebp),%ebx
    2d06:	8b 75 fc             	mov    0xfffffffc(%ebp),%esi
    2d09:	89 ec                	mov    %ebp,%esp
    2d0b:	5d                   	pop    %ebp
    2d0c:	c3                   	ret    
    2d0d:	8d 76 00             	lea    0x0(%esi),%esi

00002d10 <gets>:
    2d10:	55                   	push   %ebp
    2d11:	89 e5                	mov    %esp,%ebp
    2d13:	57                   	push   %edi
    2d14:	56                   	push   %esi
    2d15:	31 f6                	xor    %esi,%esi
    2d17:	53                   	push   %ebx
    2d18:	83 ec 1c             	sub    $0x1c,%esp
    2d1b:	8d 5e 01             	lea    0x1(%esi),%ebx
    2d1e:	8b 7d 08             	mov    0x8(%ebp),%edi
    2d21:	3b 5d 0c             	cmp    0xc(%ebp),%ebx
    2d24:	7d 3e                	jge    2d64 <gets+0x54>
    2d26:	ba 01 00 00 00       	mov    $0x1,%edx
    2d2b:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
    2d2e:	89 54 24 08          	mov    %edx,0x8(%esp)
    2d32:	89 44 24 04          	mov    %eax,0x4(%esp)
    2d36:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
    2d3d:	e8 62 00 00 00       	call   2da4 <read>
    2d42:	85 c0                	test   %eax,%eax
    2d44:	7e 1e                	jle    2d64 <gets+0x54>
    2d46:	0f b6 45 f3          	movzbl 0xfffffff3(%ebp),%eax
    2d4a:	88 44 3b ff          	mov    %al,0xffffffff(%ebx,%edi,1)
    2d4e:	0f b6 45 f3          	movzbl 0xfffffff3(%ebp),%eax
    2d52:	3c 0a                	cmp    $0xa,%al
    2d54:	74 1c                	je     2d72 <gets+0x62>
    2d56:	3c 0d                	cmp    $0xd,%al
    2d58:	74 18                	je     2d72 <gets+0x62>
    2d5a:	89 de                	mov    %ebx,%esi
    2d5c:	8d 5e 01             	lea    0x1(%esi),%ebx
    2d5f:	3b 5d 0c             	cmp    0xc(%ebp),%ebx
    2d62:	7c c2                	jl     2d26 <gets+0x16>
    2d64:	c6 04 3e 00          	movb   $0x0,(%esi,%edi,1)
    2d68:	83 c4 1c             	add    $0x1c,%esp
    2d6b:	89 f8                	mov    %edi,%eax
    2d6d:	5b                   	pop    %ebx
    2d6e:	5e                   	pop    %esi
    2d6f:	5f                   	pop    %edi
    2d70:	5d                   	pop    %ebp
    2d71:	c3                   	ret    
    2d72:	89 de                	mov    %ebx,%esi
    2d74:	89 f8                	mov    %edi,%eax
    2d76:	c6 04 3e 00          	movb   $0x0,(%esi,%edi,1)
    2d7a:	83 c4 1c             	add    $0x1c,%esp
    2d7d:	5b                   	pop    %ebx
    2d7e:	5e                   	pop    %esi
    2d7f:	5f                   	pop    %edi
    2d80:	5d                   	pop    %ebp
    2d81:	c3                   	ret    
    2d82:	90                   	nop    
    2d83:	90                   	nop    

00002d84 <fork>:
    2d84:	b8 01 00 00 00       	mov    $0x1,%eax
    2d89:	cd 30                	int    $0x30
    2d8b:	c3                   	ret    

00002d8c <exit>:
    2d8c:	b8 02 00 00 00       	mov    $0x2,%eax
    2d91:	cd 30                	int    $0x30
    2d93:	c3                   	ret    

00002d94 <wait>:
    2d94:	b8 03 00 00 00       	mov    $0x3,%eax
    2d99:	cd 30                	int    $0x30
    2d9b:	c3                   	ret    

00002d9c <pipe>:
    2d9c:	b8 04 00 00 00       	mov    $0x4,%eax
    2da1:	cd 30                	int    $0x30
    2da3:	c3                   	ret    

00002da4 <read>:
    2da4:	b8 06 00 00 00       	mov    $0x6,%eax
    2da9:	cd 30                	int    $0x30
    2dab:	c3                   	ret    

00002dac <write>:
    2dac:	b8 05 00 00 00       	mov    $0x5,%eax
    2db1:	cd 30                	int    $0x30
    2db3:	c3                   	ret    

00002db4 <close>:
    2db4:	b8 07 00 00 00       	mov    $0x7,%eax
    2db9:	cd 30                	int    $0x30
    2dbb:	c3                   	ret    

00002dbc <kill>:
    2dbc:	b8 08 00 00 00       	mov    $0x8,%eax
    2dc1:	cd 30                	int    $0x30
    2dc3:	c3                   	ret    

00002dc4 <exec>:
    2dc4:	b8 09 00 00 00       	mov    $0x9,%eax
    2dc9:	cd 30                	int    $0x30
    2dcb:	c3                   	ret    

00002dcc <open>:
    2dcc:	b8 0a 00 00 00       	mov    $0xa,%eax
    2dd1:	cd 30                	int    $0x30
    2dd3:	c3                   	ret    

00002dd4 <mknod>:
    2dd4:	b8 0b 00 00 00       	mov    $0xb,%eax
    2dd9:	cd 30                	int    $0x30
    2ddb:	c3                   	ret    

00002ddc <unlink>:
    2ddc:	b8 0c 00 00 00       	mov    $0xc,%eax
    2de1:	cd 30                	int    $0x30
    2de3:	c3                   	ret    

00002de4 <fstat>:
    2de4:	b8 0d 00 00 00       	mov    $0xd,%eax
    2de9:	cd 30                	int    $0x30
    2deb:	c3                   	ret    

00002dec <link>:
    2dec:	b8 0e 00 00 00       	mov    $0xe,%eax
    2df1:	cd 30                	int    $0x30
    2df3:	c3                   	ret    

00002df4 <mkdir>:
    2df4:	b8 0f 00 00 00       	mov    $0xf,%eax
    2df9:	cd 30                	int    $0x30
    2dfb:	c3                   	ret    

00002dfc <chdir>:
    2dfc:	b8 10 00 00 00       	mov    $0x10,%eax
    2e01:	cd 30                	int    $0x30
    2e03:	c3                   	ret    

00002e04 <dup>:
    2e04:	b8 11 00 00 00       	mov    $0x11,%eax
    2e09:	cd 30                	int    $0x30
    2e0b:	c3                   	ret    

00002e0c <getpid>:
    2e0c:	b8 12 00 00 00       	mov    $0x12,%eax
    2e11:	cd 30                	int    $0x30
    2e13:	c3                   	ret    

00002e14 <sbrk>:
    2e14:	b8 13 00 00 00       	mov    $0x13,%eax
    2e19:	cd 30                	int    $0x30
    2e1b:	c3                   	ret    

00002e1c <sleep>:
    2e1c:	b8 14 00 00 00       	mov    $0x14,%eax
    2e21:	cd 30                	int    $0x30
    2e23:	c3                   	ret    
    2e24:	90                   	nop    
    2e25:	90                   	nop    
    2e26:	90                   	nop    
    2e27:	90                   	nop    
    2e28:	90                   	nop    
    2e29:	90                   	nop    
    2e2a:	90                   	nop    
    2e2b:	90                   	nop    
    2e2c:	90                   	nop    
    2e2d:	90                   	nop    
    2e2e:	90                   	nop    
    2e2f:	90                   	nop    

00002e30 <putc>:
#include "user.h"

static void
putc(int fd, char c)
{
    2e30:	55                   	push   %ebp
    2e31:	89 e5                	mov    %esp,%ebp
    2e33:	83 ec 18             	sub    $0x18,%esp
    2e36:	88 55 fc             	mov    %dl,0xfffffffc(%ebp)
  write(fd, &c, 1);
    2e39:	ba 01 00 00 00       	mov    $0x1,%edx
    2e3e:	89 54 24 08          	mov    %edx,0x8(%esp)
    2e42:	8d 55 fc             	lea    0xfffffffc(%ebp),%edx
    2e45:	89 54 24 04          	mov    %edx,0x4(%esp)
    2e49:	89 04 24             	mov    %eax,(%esp)
    2e4c:	e8 5b ff ff ff       	call   2dac <write>
}
    2e51:	c9                   	leave  
    2e52:	c3                   	ret    
    2e53:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
    2e59:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00002e60 <printint>:

static void
printint(int fd, int xx, int base, int sgn)
{
    2e60:	55                   	push   %ebp
    2e61:	89 e5                	mov    %esp,%ebp
    2e63:	57                   	push   %edi
    2e64:	56                   	push   %esi
    2e65:	89 ce                	mov    %ecx,%esi
    2e67:	53                   	push   %ebx
    2e68:	83 ec 1c             	sub    $0x1c,%esp
  static char digits[] = "0123456789ABCDEF";
  char buf[16];
  int i, neg;
  uint x;

  neg = 0;
  if(sgn && xx < 0){
    2e6b:	8b 5d 08             	mov    0x8(%ebp),%ebx
    2e6e:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
    2e71:	85 db                	test   %ebx,%ebx
    2e73:	74 04                	je     2e79 <printint+0x19>
    2e75:	85 d2                	test   %edx,%edx
    2e77:	78 62                	js     2edb <printint+0x7b>
    neg = 1;
    x = -xx;
  } else {
    x = xx;
    2e79:	89 d0                	mov    %edx,%eax
    2e7b:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
    2e82:	31 db                	xor    %ebx,%ebx
    2e84:	8d 7d e4             	lea    0xffffffe4(%ebp),%edi
    2e87:	89 f6                	mov    %esi,%esi
    2e89:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi
  }

  i = 0;
  do{
    buf[i++] = digits[x % base];
    2e90:	31 d2                	xor    %edx,%edx
    2e92:	f7 f6                	div    %esi
    2e94:	89 c1                	mov    %eax,%ecx
    2e96:	0f b6 82 23 44 00 00 	movzbl 0x4423(%edx),%eax
    2e9d:	88 04 3b             	mov    %al,(%ebx,%edi,1)
    2ea0:	43                   	inc    %ebx
  }while((x /= base) != 0);
    2ea1:	85 c9                	test   %ecx,%ecx
    2ea3:	89 c8                	mov    %ecx,%eax
    2ea5:	75 e9                	jne    2e90 <printint+0x30>
  if(neg)
    2ea7:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
    2eaa:	85 c9                	test   %ecx,%ecx
    2eac:	74 06                	je     2eb4 <printint+0x54>
    buf[i++] = '-';
    2eae:	c6 44 1d e4 2d       	movb   $0x2d,0xffffffe4(%ebp,%ebx,1)
    2eb3:	43                   	inc    %ebx

  while(--i >= 0)
    2eb4:	4b                   	dec    %ebx
    2eb5:	78 1c                	js     2ed3 <printint+0x73>
    2eb7:	89 f6                	mov    %esi,%esi
    2eb9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi
    putc(fd, buf[i]);
    2ec0:	0f be 54 1d e4       	movsbl 0xffffffe4(%ebp,%ebx,1),%edx
    2ec5:	4b                   	dec    %ebx
    2ec6:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
    2ec9:	e8 62 ff ff ff       	call   2e30 <putc>
    2ece:	83 fb ff             	cmp    $0xffffffff,%ebx
    2ed1:	75 ed                	jne    2ec0 <printint+0x60>
}
    2ed3:	83 c4 1c             	add    $0x1c,%esp
    2ed6:	5b                   	pop    %ebx
    2ed7:	5e                   	pop    %esi
    2ed8:	5f                   	pop    %edi
    2ed9:	5d                   	pop    %ebp
    2eda:	c3                   	ret    
    2edb:	89 d0                	mov    %edx,%eax
    2edd:	f7 d8                	neg    %eax
    2edf:	c7 45 e0 01 00 00 00 	movl   $0x1,0xffffffe0(%ebp)
    2ee6:	eb 9a                	jmp    2e82 <printint+0x22>
    2ee8:	90                   	nop    
    2ee9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

00002ef0 <printf>:

// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
    2ef0:	55                   	push   %ebp
    2ef1:	89 e5                	mov    %esp,%ebp
    2ef3:	57                   	push   %edi
    2ef4:	56                   	push   %esi
    2ef5:	53                   	push   %ebx
    2ef6:	83 ec 0c             	sub    $0xc,%esp
  char *s;
  int c, i, state;
  uint *ap;

  state = 0;
  ap = (uint*)(void*)&fmt + 1;
  for(i = 0; fmt[i]; i++){
    2ef9:	8b 55 0c             	mov    0xc(%ebp),%edx
    2efc:	0f b6 02             	movzbl (%edx),%eax
    2eff:	84 c0                	test   %al,%al
    2f01:	0f 84 99 00 00 00    	je     2fa0 <printf+0xb0>
    2f07:	8d 4d 10             	lea    0x10(%ebp),%ecx
    2f0a:	31 ff                	xor    %edi,%edi
    2f0c:	31 f6                	xor    %esi,%esi
    2f0e:	89 4d f0             	mov    %ecx,0xfffffff0(%ebp)
    2f11:	eb 26                	jmp    2f39 <printf+0x49>
    c = fmt[i] & 0xff;
    if(state == 0){
      if(c == '%'){
    2f13:	83 fb 25             	cmp    $0x25,%ebx
    2f16:	0f 85 8c 00 00 00    	jne    2fa8 <printf+0xb8>
    2f1c:	be 25 00 00 00       	mov    $0x25,%esi
    2f21:	eb 0d                	jmp    2f30 <printf+0x40>
    2f23:	90                   	nop    
    2f24:	90                   	nop    
    2f25:	90                   	nop    
    2f26:	90                   	nop    
    2f27:	90                   	nop    
    2f28:	90                   	nop    
    2f29:	90                   	nop    
    2f2a:	90                   	nop    
    2f2b:	90                   	nop    
    2f2c:	90                   	nop    
    2f2d:	90                   	nop    
    2f2e:	90                   	nop    
    2f2f:	90                   	nop    
    2f30:	47                   	inc    %edi
    2f31:	0f b6 04 3a          	movzbl (%edx,%edi,1),%eax
    2f35:	84 c0                	test   %al,%al
    2f37:	74 67                	je     2fa0 <printf+0xb0>
    2f39:	85 f6                	test   %esi,%esi
    2f3b:	0f b6 d8             	movzbl %al,%ebx
    2f3e:	74 d3                	je     2f13 <printf+0x23>
        state = '%';
      } else {
        putc(fd, c);
      }
    } else if(state == '%'){
    2f40:	83 fe 25             	cmp    $0x25,%esi
    2f43:	75 eb                	jne    2f30 <printf+0x40>
      if(c == 'd'){
    2f45:	83 fb 64             	cmp    $0x64,%ebx
    2f48:	0f 84 e0 00 00 00    	je     302e <printf+0x13e>
        printint(fd, *ap, 10, 1);
        ap++;
      } else if(c == 'x' || c == 'p'){
    2f4e:	83 fb 78             	cmp    $0x78,%ebx
    2f51:	74 68                	je     2fbb <printf+0xcb>
    2f53:	83 fb 70             	cmp    $0x70,%ebx
    2f56:	74 63                	je     2fbb <printf+0xcb>
        printint(fd, *ap, 16, 0);
        ap++;
      } else if(c == 's'){
    2f58:	83 fb 73             	cmp    $0x73,%ebx
    2f5b:	90                   	nop    
    2f5c:	8d 74 26 00          	lea    0x0(%esi),%esi
    2f60:	0f 84 7c 00 00 00    	je     2fe2 <printf+0xf2>
        s = (char*)*ap;
        ap++;
        if(s == 0)
          s = "(null)";
        while(*s != 0){
          putc(fd, *s);
          s++;
        }
      } else if(c == 'c'){
    2f66:	83 fb 63             	cmp    $0x63,%ebx
    2f69:	0f 84 e4 00 00 00    	je     3053 <printf+0x163>
        putc(fd, *ap);
        ap++;
      } else if(c == '%'){
    2f6f:	83 fb 25             	cmp    $0x25,%ebx
    2f72:	0f 84 c4 00 00 00    	je     303c <printf+0x14c>
        putc(fd, c);
      } else {
        // Unknown % sequence.  Print it to draw attention.
        putc(fd, '%');
    2f78:	8b 45 08             	mov    0x8(%ebp),%eax
    2f7b:	ba 25 00 00 00       	mov    $0x25,%edx
    2f80:	47                   	inc    %edi
        putc(fd, c);
    2f81:	31 f6                	xor    %esi,%esi
    2f83:	e8 a8 fe ff ff       	call   2e30 <putc>
    2f88:	8b 45 08             	mov    0x8(%ebp),%eax
    2f8b:	0f be d3             	movsbl %bl,%edx
    2f8e:	e8 9d fe ff ff       	call   2e30 <putc>
    2f93:	8b 55 0c             	mov    0xc(%ebp),%edx
    2f96:	0f b6 04 3a          	movzbl (%edx,%edi,1),%eax
    2f9a:	84 c0                	test   %al,%al
    2f9c:	75 9b                	jne    2f39 <printf+0x49>
    2f9e:	89 f6                	mov    %esi,%esi
      }
      state = 0;
    }
  }
}
    2fa0:	83 c4 0c             	add    $0xc,%esp
    2fa3:	5b                   	pop    %ebx
    2fa4:	5e                   	pop    %esi
    2fa5:	5f                   	pop    %edi
    2fa6:	5d                   	pop    %ebp
    2fa7:	c3                   	ret    
    2fa8:	8b 45 08             	mov    0x8(%ebp),%eax
    2fab:	0f be d3             	movsbl %bl,%edx
    2fae:	e8 7d fe ff ff       	call   2e30 <putc>
    2fb3:	8b 55 0c             	mov    0xc(%ebp),%edx
    2fb6:	e9 75 ff ff ff       	jmp    2f30 <printf+0x40>
    2fbb:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
    2fc2:	b9 10 00 00 00       	mov    $0x10,%ecx
    2fc7:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    2fca:	31 f6                	xor    %esi,%esi
    2fcc:	8b 10                	mov    (%eax),%edx
    2fce:	8b 45 08             	mov    0x8(%ebp),%eax
    2fd1:	e8 8a fe ff ff       	call   2e60 <printint>
    2fd6:	8b 55 0c             	mov    0xc(%ebp),%edx
    2fd9:	83 45 f0 04          	addl   $0x4,0xfffffff0(%ebp)
    2fdd:	e9 4e ff ff ff       	jmp    2f30 <printf+0x40>
    2fe2:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
    2fe5:	8b 01                	mov    (%ecx),%eax
    2fe7:	83 c1 04             	add    $0x4,%ecx
    2fea:	89 4d f0             	mov    %ecx,0xfffffff0(%ebp)
    2fed:	b9 1c 44 00 00       	mov    $0x441c,%ecx
    2ff2:	85 c0                	test   %eax,%eax
    2ff4:	74 02                	je     2ff8 <printf+0x108>
    2ff6:	89 c1                	mov    %eax,%ecx
    2ff8:	0f b6 01             	movzbl (%ecx),%eax
    2ffb:	84 c0                	test   %al,%al
    2ffd:	74 28                	je     3027 <printf+0x137>
    2fff:	89 cb                	mov    %ecx,%ebx
    3001:	eb 0d                	jmp    3010 <printf+0x120>
    3003:	90                   	nop    
    3004:	90                   	nop    
    3005:	90                   	nop    
    3006:	90                   	nop    
    3007:	90                   	nop    
    3008:	90                   	nop    
    3009:	90                   	nop    
    300a:	90                   	nop    
    300b:	90                   	nop    
    300c:	90                   	nop    
    300d:	90                   	nop    
    300e:	90                   	nop    
    300f:	90                   	nop    
    3010:	0f be d0             	movsbl %al,%edx
    3013:	8b 45 08             	mov    0x8(%ebp),%eax
    3016:	e8 15 fe ff ff       	call   2e30 <putc>
    301b:	0f b6 43 01          	movzbl 0x1(%ebx),%eax
    301f:	43                   	inc    %ebx
    3020:	84 c0                	test   %al,%al
    3022:	75 ec                	jne    3010 <printf+0x120>
    3024:	8b 55 0c             	mov    0xc(%ebp),%edx
    3027:	31 f6                	xor    %esi,%esi
    3029:	e9 02 ff ff ff       	jmp    2f30 <printf+0x40>
    302e:	b9 0a 00 00 00       	mov    $0xa,%ecx
    3033:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
    303a:	eb 8b                	jmp    2fc7 <printf+0xd7>
    303c:	8b 45 08             	mov    0x8(%ebp),%eax
    303f:	ba 25 00 00 00       	mov    $0x25,%edx
    3044:	31 f6                	xor    %esi,%esi
    3046:	e8 e5 fd ff ff       	call   2e30 <putc>
    304b:	8b 55 0c             	mov    0xc(%ebp),%edx
    304e:	e9 dd fe ff ff       	jmp    2f30 <printf+0x40>
    3053:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
    3056:	31 f6                	xor    %esi,%esi
    3058:	0f be 10             	movsbl (%eax),%edx
    305b:	8b 45 08             	mov    0x8(%ebp),%eax
    305e:	e8 cd fd ff ff       	call   2e30 <putc>
    3063:	8b 55 0c             	mov    0xc(%ebp),%edx
    3066:	83 45 f0 04          	addl   $0x4,0xfffffff0(%ebp)
    306a:	e9 c1 fe ff ff       	jmp    2f30 <printf+0x40>
    306f:	90                   	nop    

00003070 <free>:
static Header *freep;

void
free(void *ap)
{
    3070:	55                   	push   %ebp
  Header *bp, *p;

  bp = (Header*) ap - 1;
  for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
    3071:	8b 0d 68 44 00 00    	mov    0x4468,%ecx
    3077:	89 e5                	mov    %esp,%ebp
    3079:	56                   	push   %esi
    307a:	53                   	push   %ebx
    307b:	8b 5d 08             	mov    0x8(%ebp),%ebx
    307e:	83 eb 08             	sub    $0x8,%ebx
    3081:	eb 0d                	jmp    3090 <free+0x20>
    3083:	90                   	nop    
    3084:	90                   	nop    
    3085:	90                   	nop    
    3086:	90                   	nop    
    3087:	90                   	nop    
    3088:	90                   	nop    
    3089:	90                   	nop    
    308a:	90                   	nop    
    308b:	90                   	nop    
    308c:	90                   	nop    
    308d:	90                   	nop    
    308e:	90                   	nop    
    308f:	90                   	nop    
    3090:	39 d9                	cmp    %ebx,%ecx
    3092:	73 04                	jae    3098 <free+0x28>
    3094:	3b 19                	cmp    (%ecx),%ebx
    3096:	72 12                	jb     30aa <free+0x3a>
    if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
    3098:	8b 11                	mov    (%ecx),%edx
    309a:	39 d1                	cmp    %edx,%ecx
    309c:	72 08                	jb     30a6 <free+0x36>
    309e:	39 d9                	cmp    %ebx,%ecx
    30a0:	72 0a                	jb     30ac <free+0x3c>
    30a2:	39 d3                	cmp    %edx,%ebx
    30a4:	72 06                	jb     30ac <free+0x3c>
    30a6:	89 d1                	mov    %edx,%ecx
    30a8:	eb e6                	jmp    3090 <free+0x20>
    30aa:	8b 11                	mov    (%ecx),%edx
      break;
  if(bp + bp->s.size == p->s.ptr){
    30ac:	8b 73 04             	mov    0x4(%ebx),%esi
    30af:	8d 04 f3             	lea    (%ebx,%esi,8),%eax
    30b2:	39 d0                	cmp    %edx,%eax
    30b4:	74 2e                	je     30e4 <free+0x74>
    bp->s.size += p->s.ptr->s.size;
    bp->s.ptr = p->s.ptr->s.ptr;
  } else
    bp->s.ptr = p->s.ptr;
    30b6:	89 13                	mov    %edx,(%ebx)
  if(p + p->s.size == bp){
    30b8:	8b 51 04             	mov    0x4(%ecx),%edx
    30bb:	8d 04 d1             	lea    (%ecx,%edx,8),%eax
    30be:	39 c3                	cmp    %eax,%ebx
    30c0:	74 0c                	je     30ce <free+0x5e>
    p->s.size += bp->s.size;
    p->s.ptr = bp->s.ptr;
  } else
    p->s.ptr = bp;
    30c2:	89 19                	mov    %ebx,(%ecx)
  freep = p;
}
    30c4:	5b                   	pop    %ebx
    30c5:	89 0d 68 44 00 00    	mov    %ecx,0x4468
    30cb:	5e                   	pop    %esi
    30cc:	5d                   	pop    %ebp
    30cd:	c3                   	ret    
    30ce:	8b 43 04             	mov    0x4(%ebx),%eax
    30d1:	01 c2                	add    %eax,%edx
    30d3:	8b 03                	mov    (%ebx),%eax
    30d5:	89 51 04             	mov    %edx,0x4(%ecx)
    30d8:	89 01                	mov    %eax,(%ecx)
    30da:	5b                   	pop    %ebx
    30db:	89 0d 68 44 00 00    	mov    %ecx,0x4468
    30e1:	5e                   	pop    %esi
    30e2:	5d                   	pop    %ebp
    30e3:	c3                   	ret    
    30e4:	8b 42 04             	mov    0x4(%edx),%eax
    30e7:	01 c6                	add    %eax,%esi
    30e9:	8b 02                	mov    (%edx),%eax
    30eb:	89 73 04             	mov    %esi,0x4(%ebx)
    30ee:	89 03                	mov    %eax,(%ebx)
    30f0:	eb c6                	jmp    30b8 <free+0x48>
    30f2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
    30f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00003100 <malloc>:

static Header*
morecore(uint nu)
{
  char *p;
  Header *hp;

  if(nu < PAGE)
    nu = PAGE;
  p = sbrk(nu * sizeof(Header));
  if(p == (char*) -1)
    return 0;
  hp = (Header*)p;
  hp->s.size = nu;
  free((void*)(hp + 1));
  return freep;
}

void*
malloc(uint nbytes)
{
    3100:	55                   	push   %ebp
    3101:	89 e5                	mov    %esp,%ebp
    3103:	57                   	push   %edi
    3104:	56                   	push   %esi
    3105:	53                   	push   %ebx
    3106:	83 ec 0c             	sub    $0xc,%esp
  Header *p, *prevp;
  uint nunits;

  nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
    3109:	8b 45 08             	mov    0x8(%ebp),%eax
  if((prevp = freep) == 0){
    310c:	8b 15 68 44 00 00    	mov    0x4468,%edx
    3112:	83 c0 07             	add    $0x7,%eax
    3115:	c1 e8 03             	shr    $0x3,%eax
    3118:	85 d2                	test   %edx,%edx
    311a:	8d 58 01             	lea    0x1(%eax),%ebx
    311d:	0f 84 92 00 00 00    	je     31b5 <malloc+0xb5>
    base.s.ptr = freep = prevp = &base;
    base.s.size = 0;
  }
  for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
    3123:	8b 0a                	mov    (%edx),%ecx
    if(p->s.size >= nunits){
    3125:	8b 41 04             	mov    0x4(%ecx),%eax
    3128:	39 c3                	cmp    %eax,%ebx
    312a:	76 63                	jbe    318f <malloc+0x8f>
      if(p->s.size == nunits)
        prevp->s.ptr = p->s.ptr;
      else {
        p->s.size -= nunits;
        p += p->s.size;
        p->s.size = nunits;
      }
      freep = prevp;
      return (void*) (p + 1);
    312c:	8d 3c dd 00 00 00 00 	lea    0x0(,%ebx,8),%edi
    3133:	eb 09                	jmp    313e <malloc+0x3e>
    3135:	8b 0a                	mov    (%edx),%ecx
    3137:	8b 41 04             	mov    0x4(%ecx),%eax
    313a:	39 c3                	cmp    %eax,%ebx
    313c:	76 51                	jbe    318f <malloc+0x8f>
    }
    if(p == freep)
    313e:	39 0d 68 44 00 00    	cmp    %ecx,0x4468
    3144:	89 ca                	mov    %ecx,%edx
    3146:	75 ed                	jne    3135 <malloc+0x35>
    3148:	81 fb ff 0f 00 00    	cmp    $0xfff,%ebx
    314e:	77 39                	ja     3189 <malloc+0x89>
    3150:	be 00 10 00 00       	mov    $0x1000,%esi
    3155:	b8 00 80 00 00       	mov    $0x8000,%eax
    315a:	89 04 24             	mov    %eax,(%esp)
    315d:	e8 b2 fc ff ff       	call   2e14 <sbrk>
    3162:	83 f8 ff             	cmp    $0xffffffff,%eax
    3165:	74 18                	je     317f <malloc+0x7f>
    3167:	89 70 04             	mov    %esi,0x4(%eax)
    316a:	83 c0 08             	add    $0x8,%eax
    316d:	89 04 24             	mov    %eax,(%esp)
    3170:	e8 fb fe ff ff       	call   3070 <free>
    3175:	8b 15 68 44 00 00    	mov    0x4468,%edx
      if((p = morecore(nunits)) == 0)
    317b:	85 d2                	test   %edx,%edx
    317d:	75 b6                	jne    3135 <malloc+0x35>
        return 0;
  }
}
    317f:	83 c4 0c             	add    $0xc,%esp
    3182:	31 c0                	xor    %eax,%eax
    3184:	5b                   	pop    %ebx
    3185:	5e                   	pop    %esi
    3186:	5f                   	pop    %edi
    3187:	5d                   	pop    %ebp
    3188:	c3                   	ret    
    3189:	89 de                	mov    %ebx,%esi
    318b:	89 f8                	mov    %edi,%eax
    318d:	eb cb                	jmp    315a <malloc+0x5a>
    318f:	39 c3                	cmp    %eax,%ebx
    3191:	74 1c                	je     31af <malloc+0xaf>
    3193:	29 d8                	sub    %ebx,%eax
    3195:	89 41 04             	mov    %eax,0x4(%ecx)
    3198:	8d 0c c1             	lea    (%ecx,%eax,8),%ecx
    319b:	89 59 04             	mov    %ebx,0x4(%ecx)
    319e:	89 15 68 44 00 00    	mov    %edx,0x4468
    31a4:	83 c4 0c             	add    $0xc,%esp
    31a7:	5b                   	pop    %ebx
    31a8:	8d 41 08             	lea    0x8(%ecx),%eax
    31ab:	5e                   	pop    %esi
    31ac:	5f                   	pop    %edi
    31ad:	5d                   	pop    %ebp
    31ae:	c3                   	ret    
    31af:	8b 01                	mov    (%ecx),%eax
    31b1:	89 02                	mov    %eax,(%edx)
    31b3:	eb e9                	jmp    319e <malloc+0x9e>
    31b5:	b8 60 44 00 00       	mov    $0x4460,%eax
    31ba:	ba 60 44 00 00       	mov    $0x4460,%edx
    31bf:	a3 68 44 00 00       	mov    %eax,0x4468
    31c4:	b8 60 44 00 00       	mov    $0x4460,%eax
    31c9:	a3 60 44 00 00       	mov    %eax,0x4460
    31ce:	31 c0                	xor    %eax,%eax
    31d0:	a3 64 44 00 00       	mov    %eax,0x4464
    31d5:	e9 49 ff ff ff       	jmp    3123 <malloc+0x23>