commit 3d9b2dcfc601b3f035020b1bf61cc9c60592add4
Author: Freya Murphy <freya@freyacat.org>
Date:   Wed Sep 25 15:00:19 2024 -0400

    inital checkout from try

diff --git a/CODING b/CODING
new file mode 100644
index 0000000..898097e
--- /dev/null
+++ b/CODING
@@ -0,0 +1,37 @@
+JOS CODING STANDARDS
+
+It's easier on everyone if all authors working on a shared
+code base are consistent in the way they write their programs.
+We have the following conventions in our code:
+
+* No space after the name of a function in a call
+  For example, printf("hello") not printf ("hello").
+
+* One space after keywords "if", "for", "while", "switch".
+  For example, if (x) not if(x).
+
+* Space before braces.
+  For example, if (x) { not if (x){.
+
+* Function names are all lower-case separated by underscores.
+
+* Beginning-of-line indentation via tabs, not spaces.
+
+* Preprocessor macros are always UPPERCASE.
+  There are a few grandfathered exceptions: assert, panic,
+  static_assert, offsetof.
+
+* Pointer types have spaces: (uint16_t *) not (uint16_t*).
+
+* Multi-word names are lower_case_with_underscores.
+
+* Comments in imported code are usually C /* ... */ comments.
+  Comments in new code are C++ style //.
+
+* In a function definition, the function name starts a new line.
+  Then you can grep -n '^foo' */*.c to find the definition of foo.
+
+* Functions that take no arguments are declared f(void) not f().
+
+The included .dir-locals.el file will automatically set up the basic
+indentation style in Emacs.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..33cd4aa
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,170 @@
+#
+# This makefile system follows the structuring conventions
+# recommended by Peter Miller in his excellent paper:
+#
+#	Recursive Make Considered Harmful
+#	http://aegis.sourceforge.net/auug97.pdf
+#
+OBJDIR := obj
+
+# Run 'make V=1' to turn on verbose commands, or 'make V=0' to turn them off.
+ifeq ($(V),1)
+override V =
+endif
+ifeq ($(V),0)
+override V = @
+endif
+
+-include conf/env.mk
+
+LABSETUP ?= ./
+
+TOP = .
+
+# try to generate a unique GDB port
+GDBPORT	:= $(shell expr `id -u` % 5000 + 25000)
+
+CC	:= $(GCCPREFIX)gcc -pipe
+AS	:= $(GCCPREFIX)as
+AR	:= $(GCCPREFIX)ar
+LD	:= $(GCCPREFIX)ld
+OBJCOPY	:= $(GCCPREFIX)objcopy
+OBJDUMP	:= $(GCCPREFIX)objdump
+NM	:= $(GCCPREFIX)nm
+
+QEMU = /home/course/csci352/bin/qemu-system-i386
+
+# Native commands
+NCC	:= gcc $(CC_VER) -pipe
+NATIVE_CFLAGS := $(CFLAGS) $(DEFS) $(LABDEFS) -I$(TOP) -MD -Wall
+TAR	:= tar
+PERL	:= perl
+
+# Compiler flags
+# -fno-builtin is required to avoid refs to undefined functions in the kernel.
+# Only optimize to -O1 to discourage inlining, which complicates backtraces.
+CFLAGS := $(CFLAGS) $(DEFS) $(LABDEFS) -O1 -fno-builtin -I$(TOP) -MD
+CFLAGS += -fno-omit-frame-pointer
+CFLAGS += -std=gnu99
+CFLAGS += -static
+CFLAGS += -Wall -Wno-format -Wno-unused -Werror -gstabs -m32
+# -fno-tree-ch prevented gcc from sometimes reordering read_ebp() before
+# mon_backtrace()'s function prologue on gcc version: (Debian 4.7.2-5) 4.7.2
+CFLAGS += -fno-tree-ch
+
+# prevent relative addressing and dynamic linking
+CFLAGS += -fno-pic -fno-pie
+
+# Add -fno-stack-protector if the option exists.
+CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector)
+
+# Common linker flags
+LDFLAGS := -m elf_i386
+# this can cause some strange behavior with GNU ld for some reason
+#LDFLAGS += -no-pie
+
+# Linker flags for JOS user programs
+ULDFLAGS := -T user/user.ld
+
+GCC_LIB := $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
+
+# Lists that the */Makefrag makefile fragments will add to
+OBJDIRS :=
+
+# Make sure that 'all' is the first target
+all:
+
+# Eliminate default suffix rules
+.SUFFIXES:
+
+# Delete target files if there is an error (or make is interrupted)
+.DELETE_ON_ERROR:
+
+# make it so that no intermediate .o files are ever deleted
+.PRECIOUS: %.o $(OBJDIR)/boot/%.o $(OBJDIR)/kern/%.o \
+	   $(OBJDIR)/lib/%.o $(OBJDIR)/fs/%.o $(OBJDIR)/net/%.o \
+	   $(OBJDIR)/user/%.o
+
+KERN_CFLAGS := $(CFLAGS) -DJOS_KERNEL -gstabs
+USER_CFLAGS := $(CFLAGS) -DJOS_USER -gstabs
+
+# Update .vars.X if variable X has changed since the last make run.
+#
+# Rules that use variable X should depend on $(OBJDIR)/.vars.X.  If
+# the variable's value has changed, this will update the vars file and
+# force a rebuild of the rule that depends on it.
+$(OBJDIR)/.vars.%: FORCE
+	$(V)echo "$($*)" | cmp -s $@ || echo "$($*)" > $@
+.PRECIOUS: $(OBJDIR)/.vars.%
+.PHONY: FORCE
+
+
+# Include Makefrags for subdirectories
+include boot/Makefrag
+include kern/Makefrag
+
+
+QEMUOPTS = -drive file=$(OBJDIR)/kern/kernel.img,index=0,media=disk,format=raw -serial mon:stdio -gdb tcp::$(GDBPORT)
+QEMUOPTS += $(shell if $(QEMU) -nographic -help | grep -q '^-D '; then echo '-D qemu.log'; fi)
+IMAGES = $(OBJDIR)/kern/kernel.img
+QEMUOPTS += $(QEMUEXTRA)
+
+.gdbinit: gdbinit.tmpl
+	sed "s/localhost:1234/localhost:$(GDBPORT)/" < $^ > $@
+
+gdb:
+	gdb -q -n -x .gdbinit
+
+pre-qemu: .gdbinit
+
+qemu: $(IMAGES) pre-qemu
+	$(QEMU) $(QEMUOPTS)
+
+qemu-nox: $(IMAGES) pre-qemu
+	@echo "***"
+	@echo "*** Use Ctrl-a x to exit qemu"
+	@echo "***"
+	$(QEMU) -nographic $(QEMUOPTS)
+
+qemu-gdb: $(IMAGES) pre-qemu
+	@echo "***"
+	@echo "*** Now run 'make gdb'." 1>&2
+	@echo "***"
+	$(QEMU) $(QEMUOPTS) -S
+
+qemu-nox-gdb: $(IMAGES) pre-qemu
+	@echo "***"
+	@echo "*** Now run 'make gdb'." 1>&2
+	@echo "***"
+	$(QEMU) -nographic $(QEMUOPTS) -S
+
+print-qemu:
+	@echo $(QEMU)
+
+print-gdbport:
+	@echo $(GDBPORT)
+
+# For deleting the build
+clean:
+	rm -rf $(OBJDIR) .gdbinit jos.in qemu.log
+
+realclean: clean
+
+distclean: realclean
+	rm -rf conf/gcc.mk
+
+# This magic automatically generates makefile dependencies
+# for header files included from C source files we compile,
+# and keeps those dependencies up-to-date every time we recompile.
+# See 'mergedep.pl' for more information.
+$(OBJDIR)/.deps: $(foreach dir, $(OBJDIRS), $(wildcard $(OBJDIR)/$(dir)/*.d))
+	@mkdir -p $(@D)
+	@$(PERL) mergedep.pl $@ $^
+
+-include $(OBJDIR)/.deps
+
+always:
+	@:
+
+.PHONY: all always \
+	clean realclean distclean
diff --git a/boot/Makefrag b/boot/Makefrag
new file mode 100644
index 0000000..a2f49f8
--- /dev/null
+++ b/boot/Makefrag
@@ -0,0 +1,32 @@
+#
+# Makefile fragment for the JOS kernel.
+# This is NOT a complete makefile;
+# you must run GNU make in the top-level directory
+# where the GNUmakefile is located.
+#
+
+OBJDIRS += boot
+
+BOOT_OBJS := $(OBJDIR)/boot/boot.o $(OBJDIR)/boot/main.o
+
+$(OBJDIR)/boot/%.o: boot/%.c
+	@echo + cc -Os $<
+	@mkdir -p $(@D)
+	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -Os -c -o $@ $<
+
+$(OBJDIR)/boot/%.o: boot/%.S
+	@echo + as $<
+	@mkdir -p $(@D)
+	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -c -o $@ $<
+
+$(OBJDIR)/boot/main.o: boot/main.c
+	@echo + cc -Os $<
+	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -Os -c -o $(OBJDIR)/boot/main.o boot/main.c
+
+$(OBJDIR)/boot/boot: $(BOOT_OBJS)
+	@echo + ld boot/boot
+	$(V)$(LD) $(LDFLAGS) -N -e start -Ttext 0x7C00 -o $@.out $^
+	$(V)$(OBJDUMP) -S $@.out >$@.asm
+	$(V)$(OBJCOPY) -S -O binary -j .text $@.out $@
+	$(V)perl boot/sign.pl $(OBJDIR)/boot/boot
+
diff --git a/boot/boot.S b/boot/boot.S
new file mode 100644
index 0000000..7a91ab1
--- /dev/null
+++ b/boot/boot.S
@@ -0,0 +1,85 @@
+#include <inc/mmu.h>
+
+# Start the CPU: switch to 32-bit protected mode, jump into C.
+# The BIOS loads this code from the first sector of the hard disk into
+# memory at physical address 0x7c00 and starts executing in real mode
+# with %cs=0 %ip=7c00.
+
+.set PROT_MODE_CSEG, 0x8         # kernel code segment selector
+.set PROT_MODE_DSEG, 0x10        # kernel data segment selector
+.set CR0_PE_ON,      0x1         # protected mode enable flag
+
+.globl start
+start:
+  .code16                     # Assemble for 16-bit mode
+  cli                         # Disable interrupts
+  cld                         # String operations increment
+
+  # Set up the important data segment registers (DS, ES, SS).
+  xorw    %ax,%ax             # Segment number zero
+  movw    %ax,%ds             # -> Data Segment
+  movw    %ax,%es             # -> Extra Segment
+  movw    %ax,%ss             # -> Stack Segment
+
+  # Enable A20:
+  #   For backwards compatibility with the earliest PCs, physical
+  #   address line 20 is tied low, so that addresses higher than
+  #   1MB wrap around to zero by default.  This code undoes this.
+seta20.1:
+  inb     $0x64,%al               # Wait for not busy
+  testb   $0x2,%al
+  jnz     seta20.1
+
+  movb    $0xd1,%al               # 0xd1 -> port 0x64
+  outb    %al,$0x64
+
+seta20.2:
+  inb     $0x64,%al               # Wait for not busy
+  testb   $0x2,%al
+  jnz     seta20.2
+
+  movb    $0xdf,%al               # 0xdf -> port 0x60
+  outb    %al,$0x60
+
+  # Switch from real to protected mode, using a bootstrap GDT
+  # and segment translation that makes virtual addresses 
+  # identical to their physical addresses, so that the 
+  # effective memory map does not change during the switch.
+  lgdt    gdtdesc
+  movl    %cr0, %eax
+  orl     $CR0_PE_ON, %eax
+  movl    %eax, %cr0
+  
+  # Jump to next instruction, but in 32-bit code segment.
+  # Switches processor into 32-bit mode.
+  ljmp    $PROT_MODE_CSEG, $protcseg
+
+  .code32                     # Assemble for 32-bit mode
+protcseg:
+  # Set up the protected-mode data segment registers
+  movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
+  movw    %ax, %ds                # -> DS: Data Segment
+  movw    %ax, %es                # -> ES: Extra Segment
+  movw    %ax, %fs                # -> FS
+  movw    %ax, %gs                # -> GS
+  movw    %ax, %ss                # -> SS: Stack Segment
+  
+  # Set up the stack pointer and call into C.
+  movl    $start, %esp
+  call bootmain
+
+  # If bootmain returns (it shouldn't), loop.
+spin:
+  jmp spin
+
+# Bootstrap GDT
+.p2align 2                                # force 4 byte alignment
+gdt:
+  SEG_NULL				# null seg
+  SEG(STA_X|STA_R, 0x0, 0xffffffff)	# code seg
+  SEG(STA_W, 0x0, 0xffffffff)	        # data seg
+
+gdtdesc:
+  .word   0x17                            # sizeof(gdt) - 1
+  .long   gdt                             # address gdt
+
diff --git a/boot/main.c b/boot/main.c
new file mode 100644
index 0000000..c230272
--- /dev/null
+++ b/boot/main.c
@@ -0,0 +1,125 @@
+#include <inc/x86.h>
+#include <inc/elf.h>
+
+/**********************************************************************
+ * This a dirt simple boot loader, whose sole job is to boot
+ * an ELF kernel image from the first IDE hard disk.
+ *
+ * DISK LAYOUT
+ *  * This program(boot.S and main.c) is the bootloader.  It should
+ *    be stored in the first sector of the disk.
+ *
+ *  * The 2nd sector onward holds the kernel image.
+ *
+ *  * The kernel image must be in ELF format.
+ *
+ * BOOT UP STEPS
+ *  * when the CPU boots it loads the BIOS into memory and executes it
+ *
+ *  * the BIOS intializes devices, sets of the interrupt routines, and
+ *    reads the first sector of the boot device(e.g., hard-drive)
+ *    into memory and jumps to it.
+ *
+ *  * Assuming this boot loader is stored in the first sector of the
+ *    hard-drive, this code takes over...
+ *
+ *  * control starts in boot.S -- which sets up protected mode,
+ *    and a stack so C code then run, then calls bootmain()
+ *
+ *  * bootmain() in this file takes over, reads in the kernel and jumps to it.
+ **********************************************************************/
+
+#define SECTSIZE	512
+#define ELFHDR		((struct Elf *) 0x10000) // scratch space
+
+void readsect(void*, uint32_t);
+void readseg(uint32_t, uint32_t, uint32_t);
+
+void
+bootmain(void)
+{
+	struct Proghdr *ph, *eph;
+
+	// read 1st page off disk
+	readseg((uint32_t) ELFHDR, SECTSIZE*8, 0);
+
+	// is this a valid ELF?
+	if (ELFHDR->e_magic != ELF_MAGIC)
+		goto bad;
+
+	// load each program segment (ignores ph flags)
+	ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
+	eph = ph + ELFHDR->e_phnum;
+	for (; ph < eph; ph++)
+		// p_pa is the load address of this segment (as well
+		// as the physical address)
+		readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
+
+	// call the entry point from the ELF header
+	// note: does not return!
+	((void (*)(void)) (ELFHDR->e_entry))();
+
+bad:
+	outw(0x8A00, 0x8A00);
+	outw(0x8A00, 0x8E00);
+	while (1)
+		/* do nothing */;
+}
+
+// Read 'count' bytes at 'offset' from kernel into physical address 'pa'.
+// Might copy more than asked
+void
+readseg(uint32_t pa, uint32_t count, uint32_t offset)
+{
+	uint32_t end_pa;
+
+	end_pa = pa + count;
+
+	// round down to sector boundary
+	pa &= ~(SECTSIZE - 1);
+
+	// translate from bytes to sectors, and kernel starts at sector 1
+	offset = (offset / SECTSIZE) + 1;
+
+	// If this is too slow, we could read lots of sectors at a time.
+	// We'd write more to memory than asked, but it doesn't matter --
+	// we load in increasing order.
+	while (pa < end_pa) {
+		// Since we haven't enabled paging yet and we're using
+		// an identity segment mapping (see boot.S), we can
+		// use physical addresses directly.  This won't be the
+		// case once JOS enables the MMU.
+		readsect((uint8_t*) pa, offset);
+		pa += SECTSIZE;
+		offset++;
+	}
+}
+
+void
+waitdisk(void)
+{
+	// wait for disk reaady
+	while ((inb(0x1F7) & 0xC0) != 0x40)
+		/* do nothing */;
+}
+
+void
+readsect(void *dst, uint32_t offset)
+{
+	// wait for disk to be ready
+	waitdisk();
+
+	outb(0x1F2, 1);		// count = 1
+	outb(0x1F3, offset);
+	outb(0x1F4, offset >> 8);
+	outb(0x1F5, offset >> 16);
+	outb(0x1F6, (offset >> 24) | 0xE0);
+	outb(0x1F7, 0x20);	// cmd 0x20 - read sectors
+
+	// wait for disk to be ready
+	waitdisk();
+
+	// read a sector
+	insl(0x1F0, dst, SECTSIZE/4);
+}
+
diff --git a/boot/sign.pl b/boot/sign.pl
new file mode 100644
index 0000000..0bf46cb
--- /dev/null
+++ b/boot/sign.pl
@@ -0,0 +1,23 @@
+#!/usr/bin/perl
+
+open(BB, $ARGV[0]) || die "open $ARGV[0]: $!";
+
+binmode BB;
+my $buf;
+read(BB, $buf, 1000);
+$n = length($buf);
+
+if($n > 510){
+	print STDERR "boot block too large: $n bytes (max 510)\n";
+	exit 1;
+}
+
+print STDERR "boot block is $n bytes (max 510)\n";
+
+$buf .= "\0" x (510-$n);
+$buf .= "\x55\xAA";
+
+open(BB, ">$ARGV[0]") || die "open >$ARGV[0]: $!";
+binmode BB;
+print BB $buf;
+close BB;
diff --git a/conf/env.mk b/conf/env.mk
new file mode 100644
index 0000000..03b5ae2
--- /dev/null
+++ b/conf/env.mk
@@ -0,0 +1,16 @@
+# env.mk - configuration variables for the JOS lab
+
+# '$(V)' controls whether the lab makefiles print verbose commands (the
+# actual shell commands run by Make), as well as the "overview" commands
+# (such as '+ cc lib/readline.c').
+#
+# For overview commands only, the line should read 'V = @'.
+# For overview and verbose commands, the line should read 'V ='.
+V = @
+
+# If your system-standard GNU toolchain is not ELF-compatible, uncomment
+# and edit the following line to use those tools. The value should be the
+# prefix portion of the command names (e.g., /usr/bin/x86_64-linux-gnu-gcc
+# would define GCCPREFIX=x86_64-linux-gnu-)
+#
+# GCCPREFIX=
diff --git a/fs/test.c b/fs/test.c
new file mode 100644
index 0000000..c2b743e
--- /dev/null
+++ b/fs/test.c
@@ -0,0 +1,67 @@
+#include <inc/x86.h>
+#include <inc/string.h>
+
+#include "fs.h"
+
+static char *msg = "This is the NEW message of the day!\n\n";
+
+void
+fs_test(void)
+{
+	struct File *f;
+	int r;
+	char *blk;
+	uint32_t *bits;
+
+	// back up bitmap
+	if ((r = sys_page_alloc(0, (void*) PGSIZE, PTE_P|PTE_U|PTE_W)) < 0)
+		panic("sys_page_alloc: %e", r);
+	bits = (uint32_t*) PGSIZE;
+	memmove(bits, bitmap, PGSIZE);
+	// allocate block
+	if ((r = alloc_block()) < 0)
+		panic("alloc_block: %e", r);
+	// check that block was free
+	assert(bits[r/32] & (1 << (r%32)));
+	// and is not free any more
+	assert(!(bitmap[r/32] & (1 << (r%32))));
+	cprintf("alloc_block is good\n");
+
+	if ((r = file_open("/not-found", &f)) < 0 && r != -E_NOT_FOUND)
+		panic("file_open /not-found: %e", r);
+	else if (r == 0)
+		panic("file_open /not-found succeeded!");
+	if ((r = file_open("/newmotd", &f)) < 0)
+		panic("file_open /newmotd: %e", r);
+	cprintf("file_open is good\n");
+
+	if ((r = file_get_block(f, 0, &blk)) < 0)
+		panic("file_get_block: %e", r);
+	if (strcmp(blk, msg) != 0)
+		panic("file_get_block returned wrong data");
+	cprintf("file_get_block is good\n");
+
+	*(volatile char*)blk = *(volatile char*)blk;
+	assert((uvpt[PGNUM(blk)] & PTE_D));
+	file_flush(f);
+	assert(!(uvpt[PGNUM(blk)] & PTE_D));
+	cprintf("file_flush is good\n");
+
+	if ((r = file_set_size(f, 0)) < 0)
+		panic("file_set_size: %e", r);
+	assert(f->f_direct[0] == 0);
+	assert(!(uvpt[PGNUM(f)] & PTE_D));
+	cprintf("file_truncate is good\n");
+
+	if ((r = file_set_size(f, strlen(msg))) < 0)
+		panic("file_set_size 2: %e", r);
+	assert(!(uvpt[PGNUM(f)] & PTE_D));
+	if ((r = file_get_block(f, 0, &blk)) < 0)
+		panic("file_get_block 2: %e", r);
+	strcpy(blk, msg);
+	assert((uvpt[PGNUM(blk)] & PTE_D));
+	file_flush(f);
+	assert(!(uvpt[PGNUM(blk)] & PTE_D));
+	assert(!(uvpt[PGNUM(f)] & PTE_D));
+	cprintf("file rewrite is good\n");
+}
diff --git a/fs/testshell.key b/fs/testshell.key
new file mode 100644
index 0000000..c8208d2
--- /dev/null
+++ b/fs/testshell.key
@@ -0,0 +1,70 @@
+# echo hello world | cat
+hello world
+# cat lorem
+Lorem ipsum dolor sit amet, consectetur
+adipisicing elit, sed do eiusmod tempor
+incididunt ut labore et dolore magna
+aliqua. Ut enim ad minim veniam, quis
+nostrud exercitation ullamco laboris
+nisi ut aliquip ex ea commodo consequat.
+Duis aute irure dolor in reprehenderit
+in voluptate velit esse cillum dolore eu
+fugiat nulla pariatur. Excepteur sint
+occaecat cupidatat non proident, sunt in
+culpa qui officia deserunt mollit anim
+id est laborum.
+# cat lorem |num
+    1 Lorem ipsum dolor sit amet, consectetur
+    2 adipisicing elit, sed do eiusmod tempor
+    3 incididunt ut labore et dolore magna
+    4 aliqua. Ut enim ad minim veniam, quis
+    5 nostrud exercitation ullamco laboris
+    6 nisi ut aliquip ex ea commodo consequat.
+    7 Duis aute irure dolor in reprehenderit
+    8 in voluptate velit esse cillum dolore eu
+    9 fugiat nulla pariatur. Excepteur sint
+   10 occaecat cupidatat non proident, sunt in
+   11 culpa qui officia deserunt mollit anim
+   12 id est laborum.
+# cat lorem |num |num |num |num |num
+    1     1     1     1     1 Lorem ipsum dolor sit amet, consectetur
+    2     2     2     2     2 adipisicing elit, sed do eiusmod tempor
+    3     3     3     3     3 incididunt ut labore et dolore magna
+    4     4     4     4     4 aliqua. Ut enim ad minim veniam, quis
+    5     5     5     5     5 nostrud exercitation ullamco laboris
+    6     6     6     6     6 nisi ut aliquip ex ea commodo consequat.
+    7     7     7     7     7 Duis aute irure dolor in reprehenderit
+    8     8     8     8     8 in voluptate velit esse cillum dolore eu
+    9     9     9     9     9 fugiat nulla pariatur. Excepteur sint
+   10    10    10    10    10 occaecat cupidatat non proident, sunt in
+   11    11    11    11    11 culpa qui officia deserunt mollit anim
+   12    12    12    12    12 id est laborum.
+# lsfd -1
+fd 0: name testshell.sh isdir 0 size 113 dev file
+fd 1: name <pipe> isdir 0 size 32 dev pipe
+fd 3: name <pipe> isdir 0 size 32 dev pipe
+# cat script
+echo This is from the script.
+cat lorem | num | cat
+echo These are my file descriptors.
+lsfd -1
+echo This is the end of the script.
+# sh <script
+This is from the script.
+    1 Lorem ipsum dolor sit amet, consectetur
+    2 adipisicing elit, sed do eiusmod tempor
+    3 incididunt ut labore et dolore magna
+    4 aliqua. Ut enim ad minim veniam, quis
+    5 nostrud exercitation ullamco laboris
+    6 nisi ut aliquip ex ea commodo consequat.
+    7 Duis aute irure dolor in reprehenderit
+    8 in voluptate velit esse cillum dolore eu
+    9 fugiat nulla pariatur. Excepteur sint
+   10 occaecat cupidatat non proident, sunt in
+   11 culpa qui officia deserunt mollit anim
+   12 id est laborum.
+These are my file descriptors.
+fd 0: name script isdir 0 size 132 dev file
+fd 1: name <pipe> isdir 0 size 32 dev pipe
+fd 3: name <pipe> isdir 0 size 32 dev pipe
+This is the end of the script.
diff --git a/gdbinit.tmpl b/gdbinit.tmpl
new file mode 100644
index 0000000..234bb85
--- /dev/null
+++ b/gdbinit.tmpl
@@ -0,0 +1,30 @@
+set $lastcs = -1
+
+define hook-stop
+  # There doesn't seem to be a good way to detect if we're in 16- or
+  # 32-bit mode, but we always run with CS == 8 in 32-bit mode.
+  if $cs == 8 || $cs == 27
+    if $lastcs != 8 && $lastcs != 27
+      set architecture i386
+    end
+    x/i $pc
+  else
+    if $lastcs == -1 || $lastcs == 8 || $lastcs == 27
+      set architecture i8086
+    end
+    # Translate the segment:offset into a physical address
+    printf "[%4x:%4x] ", $cs, $eip
+    x/i $cs*16+$eip
+  end
+  set $lastcs = $cs
+end
+
+echo + target remote localhost:1234\n
+target remote localhost:1234
+
+# If this fails, it's probably because your GDB doesn't support ELF.
+# Look at the tools page at
+#  http://pdos.csail.mit.edu/6.828/2009/tools.html
+# for instructions on building GDB with ELF support.
+echo + symbol-file obj/kern/kernel\n
+symbol-file obj/kern/kernel
diff --git a/inc/COPYRIGHT b/inc/COPYRIGHT
new file mode 100644
index 0000000..5926652
--- /dev/null
+++ b/inc/COPYRIGHT
@@ -0,0 +1,154 @@
+The files in this directory are:
+
+/*
+ * Copyright (C) 1997 Massachusetts Institute of Technology 
+ *
+ * This software is being provided by the copyright holders under the
+ * following license. By obtaining, using and/or copying this software,
+ * you agree that you have read, understood, and will comply with the
+ * following terms and conditions:
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose and without fee or royalty is
+ * hereby granted, provided that the full text of this NOTICE appears on
+ * ALL copies of the software and documentation or portions thereof,
+ * including modifications, that you make.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO
+ * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
+ * BUT NOT LIMITATION, COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR
+ * WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR
+ * THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY
+ * THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. COPYRIGHT
+ * HOLDERS WILL BEAR NO LIABILITY FOR ANY USE OF THIS SOFTWARE OR
+ * DOCUMENTATION.
+ *
+ * The name and trademarks of copyright holders may NOT be used in
+ * advertising or publicity pertaining to the software without specific,
+ * written prior permission. Title to copyright in this software and any
+ * associated documentation will at all times remain with copyright
+ * holders. See the file AUTHORS which should have accompanied this software
+ * for a list of all copyright holders.
+ *
+ * This file may be derived from previously copyrighted software. This
+ * copyright applies only to those changes made by the copyright
+ * holders listed in the AUTHORS file. The rest of this file is covered by
+ * the copyright notices, if any, listed below.
+ */
+
+queue.h is:
+
+/* 
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)queue.h	8.5 (Berkeley) 8/20/94
+ */
+
+stdarg.h is:
+
+/*-
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)stdarg.h	8.1 (Berkeley) 6/10/93
+ */
+
+types.h is:
+
+/*-
+ * Copyright (c) 1982, 1986, 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)types.h	8.4 (Berkeley) 1/21/94
+ */
+
diff --git a/inc/assert.h b/inc/assert.h
new file mode 100644
index 0000000..aba04de
--- /dev/null
+++ b/inc/assert.h
@@ -0,0 +1,20 @@
+/* See COPYRIGHT for copyright information. */
+
+#ifndef JOS_INC_ASSERT_H
+#define JOS_INC_ASSERT_H
+
+#include <inc/stdio.h>
+
+void _warn(const char*, int, const char*, ...);
+void _panic(const char*, int, const char*, ...) __attribute__((noreturn));
+
+#define warn(...) _warn(__FILE__, __LINE__, __VA_ARGS__)
+#define panic(...) _panic(__FILE__, __LINE__, __VA_ARGS__)
+
+#define assert(x)		\
+	do { if (!(x)) panic("assertion failed: %s", #x); } while (0)
+
+// static_assert(x) will generate a compile-time error if 'x' is false.
+#define static_assert(x)	switch (x) case 0: case (x):
+
+#endif /* !JOS_INC_ASSERT_H */
diff --git a/inc/elf.h b/inc/elf.h
new file mode 100644
index 0000000..f0ce1e1
--- /dev/null
+++ b/inc/elf.h
@@ -0,0 +1,65 @@
+#ifndef JOS_INC_ELF_H
+#define JOS_INC_ELF_H
+
+#define ELF_MAGIC 0x464C457FU	/* "\x7FELF" in little endian */
+
+struct Elf {
+	uint32_t e_magic;	// must equal ELF_MAGIC
+	uint8_t e_elf[12];
+	uint16_t e_type;
+	uint16_t e_machine;
+	uint32_t e_version;
+	uint32_t e_entry;
+	uint32_t e_phoff;
+	uint32_t e_shoff;
+	uint32_t e_flags;
+	uint16_t e_ehsize;
+	uint16_t e_phentsize;
+	uint16_t e_phnum;
+	uint16_t e_shentsize;
+	uint16_t e_shnum;
+	uint16_t e_shstrndx;
+};
+
+struct Proghdr {
+	uint32_t p_type;
+	uint32_t p_offset;
+	uint32_t p_va;
+	uint32_t p_pa;
+	uint32_t p_filesz;
+	uint32_t p_memsz;
+	uint32_t p_flags;
+	uint32_t p_align;
+};
+
+struct Secthdr {
+	uint32_t sh_name;
+	uint32_t sh_type;
+	uint32_t sh_flags;
+	uint32_t sh_addr;
+	uint32_t sh_offset;
+	uint32_t sh_size;
+	uint32_t sh_link;
+	uint32_t sh_info;
+	uint32_t sh_addralign;
+	uint32_t sh_entsize;
+};
+
+// Values for Proghdr::p_type
+#define ELF_PROG_LOAD		1
+
+// Flag bits for Proghdr::p_flags
+#define ELF_PROG_FLAG_EXEC	1
+#define ELF_PROG_FLAG_WRITE	2
+#define ELF_PROG_FLAG_READ	4
+
+// Values for Secthdr::sh_type
+#define ELF_SHT_NULL		0
+#define ELF_SHT_PROGBITS	1
+#define ELF_SHT_SYMTAB		2
+#define ELF_SHT_STRTAB		3
+
+// Values for Secthdr::sh_name
+#define ELF_SHN_UNDEF		0
+
+#endif /* !JOS_INC_ELF_H */
diff --git a/inc/error.h b/inc/error.h
new file mode 100644
index 0000000..1bd522c
--- /dev/null
+++ b/inc/error.h
@@ -0,0 +1,20 @@
+/* See COPYRIGHT for copyright information. */
+
+#ifndef JOS_INC_ERROR_H
+#define JOS_INC_ERROR_H
+
+enum {
+	// Kernel error codes -- keep in sync with list in lib/printfmt.c.
+	E_UNSPECIFIED	= 1,	// Unspecified or unknown problem
+	E_BAD_ENV	,	// Environment doesn't exist or otherwise
+				// cannot be used in requested action
+	E_INVAL		,	// Invalid parameter
+	E_NO_MEM	,	// Request failed due to memory shortage
+	E_NO_FREE_ENV	,	// Attempt to create a new environment beyond
+				// the maximum allowed
+	E_FAULT		,	// Memory fault
+
+	MAXERROR
+};
+
+#endif	// !JOS_INC_ERROR_H */
diff --git a/inc/kbdreg.h b/inc/kbdreg.h
new file mode 100644
index 0000000..0ebc8d1
--- /dev/null
+++ b/inc/kbdreg.h
@@ -0,0 +1,83 @@
+#ifndef JOS_KBDREG_H
+#define JOS_KBDREG_H
+
+// Special keycodes
+#define KEY_HOME	0xE0
+#define KEY_END		0xE1
+#define KEY_UP		0xE2
+#define KEY_DN		0xE3
+#define KEY_LF		0xE4
+#define KEY_RT		0xE5
+#define KEY_PGUP	0xE6
+#define KEY_PGDN	0xE7
+#define KEY_INS		0xE8
+#define KEY_DEL		0xE9
+
+
+/* This is i8042reg.h + kbdreg.h from NetBSD. */
+
+#define	KBSTATP		0x64	/* kbd controller status port(I) */
+#define	 KBS_DIB	0x01	/* kbd data in buffer */
+#define	 KBS_IBF	0x02	/* kbd input buffer low */
+#define	 KBS_WARM	0x04	/* kbd input buffer low */
+#define	 KBS_OCMD	0x08	/* kbd output buffer has command */
+#define	 KBS_NOSEC	0x10	/* kbd security lock not engaged */
+#define	 KBS_TERR	0x20	/* kbd transmission error or from mouse */
+#define	 KBS_RERR	0x40	/* kbd receive error */
+#define	 KBS_PERR	0x80	/* kbd parity error */
+
+#define	KBCMDP		0x64	/* kbd controller port(O) */
+#define	 KBC_RAMREAD	0x20	/* read from RAM */
+#define	 KBC_RAMWRITE	0x60	/* write to RAM */
+#define	 KBC_AUXDISABLE	0xa7	/* disable auxiliary port */
+#define	 KBC_AUXENABLE	0xa8	/* enable auxiliary port */
+#define	 KBC_AUXTEST	0xa9	/* test auxiliary port */
+#define	 KBC_KBDECHO	0xd2	/* echo to keyboard port */
+#define	 KBC_AUXECHO	0xd3	/* echo to auxiliary port */
+#define	 KBC_AUXWRITE	0xd4	/* write to auxiliary port */
+#define	 KBC_SELFTEST	0xaa	/* start self-test */
+#define	 KBC_KBDTEST	0xab	/* test keyboard port */
+#define	 KBC_KBDDISABLE	0xad	/* disable keyboard port */
+#define	 KBC_KBDENABLE	0xae	/* enable keyboard port */
+#define	 KBC_PULSE0	0xfe	/* pulse output bit 0 */
+#define	 KBC_PULSE1	0xfd	/* pulse output bit 1 */
+#define	 KBC_PULSE2	0xfb	/* pulse output bit 2 */
+#define	 KBC_PULSE3	0xf7	/* pulse output bit 3 */
+
+#define	KBDATAP		0x60	/* kbd data port(I) */
+#define	KBOUTP		0x60	/* kbd data port(O) */
+
+#define	K_RDCMDBYTE	0x20
+#define	K_LDCMDBYTE	0x60
+
+#define	KC8_TRANS	0x40	/* convert to old scan codes */
+#define	KC8_MDISABLE	0x20	/* disable mouse */
+#define	KC8_KDISABLE	0x10	/* disable keyboard */
+#define	KC8_IGNSEC	0x08	/* ignore security lock */
+#define	KC8_CPU		0x04	/* exit from protected mode reset */
+#define	KC8_MENABLE	0x02	/* enable mouse interrupt */
+#define	KC8_KENABLE	0x01	/* enable keyboard interrupt */
+#define	CMDBYTE		(KC8_TRANS|KC8_CPU|KC8_MENABLE|KC8_KENABLE)
+
+/* keyboard commands */
+#define	KBC_RESET	0xFF	/* reset the keyboard */
+#define	KBC_RESEND	0xFE	/* request the keyboard resend the last byte */
+#define	KBC_SETDEFAULT	0xF6	/* resets keyboard to its power-on defaults */
+#define	KBC_DISABLE	0xF5	/* as per KBC_SETDEFAULT, but also disable key scanning */
+#define	KBC_ENABLE	0xF4	/* enable key scanning */
+#define	KBC_TYPEMATIC	0xF3	/* set typematic rate and delay */
+#define	KBC_SETTABLE	0xF0	/* set scancode translation table */
+#define	KBC_MODEIND	0xED	/* set mode indicators(i.e. LEDs) */
+#define	KBC_ECHO	0xEE	/* request an echo from the keyboard */
+
+/* keyboard responses */
+#define	KBR_EXTENDED	0xE0	/* extended key sequence */
+#define	KBR_RESEND	0xFE	/* needs resend of command */
+#define	KBR_ACK		0xFA	/* received a valid command */
+#define	KBR_OVERRUN	0x00	/* flooded */
+#define	KBR_FAILURE	0xFD	/* diagnosic failure */
+#define	KBR_BREAK	0xF0	/* break code prefix - sent on key release */
+#define	KBR_RSTDONE	0xAA	/* reset complete */
+#define	KBR_ECHO	0xEE	/* echo response */
+
+#endif /* !JOS_KBDREG_H */
diff --git a/inc/memlayout.h b/inc/memlayout.h
new file mode 100644
index 0000000..88b5730
--- /dev/null
+++ b/inc/memlayout.h
@@ -0,0 +1,147 @@
+#ifndef JOS_INC_MEMLAYOUT_H
+#define JOS_INC_MEMLAYOUT_H
+
+#ifndef __ASSEMBLER__
+#include <inc/types.h>
+#include <inc/mmu.h>
+#endif /* not __ASSEMBLER__ */
+
+/*
+ * This file contains definitions for memory management in our OS,
+ * which are relevant to both the kernel and user-mode software.
+ */
+
+// Global descriptor numbers
+#define GD_KT     0x08     // kernel text
+#define GD_KD     0x10     // kernel data
+#define GD_UT     0x18     // user text
+#define GD_UD     0x20     // user data
+#define GD_TSS0   0x28     // Task segment selector for CPU 0
+
+/*
+ * Virtual memory map:                                Permissions
+ *                                                    kernel/user
+ *
+ *    4 Gig -------->  +------------------------------+
+ *                     |                              | RW/--
+ *                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *                     :              .               :
+ *                     :              .               :
+ *                     :              .               :
+ *                     |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| RW/--
+ *                     |                              | RW/--
+ *                     |   Remapped Physical Memory   | RW/--
+ *                     |                              | RW/--
+ *    KERNBASE, ---->  +------------------------------+ 0xf0000000      --+
+ *    KSTACKTOP        |     CPU0's Kernel Stack      | RW/--  KSTKSIZE   |
+ *                     | - - - - - - - - - - - - - - -|                   |
+ *                     |      Invalid Memory (*)      | --/--  KSTKGAP    |
+ *                     +------------------------------+                   |
+ *                     |     CPU1's Kernel Stack      | RW/--  KSTKSIZE   |
+ *                     | - - - - - - - - - - - - - - -|                 PTSIZE
+ *                     |      Invalid Memory (*)      | --/--  KSTKGAP    |
+ *                     +------------------------------+                   |
+ *                     :              .               :                   |
+ *                     :              .               :                   |
+ *    MMIOLIM ------>  +------------------------------+ 0xefc00000      --+
+ *                     |       Memory-mapped I/O      | RW/--  PTSIZE
+ * ULIM, MMIOBASE -->  +------------------------------+ 0xef800000
+ *                     |  Cur. Page Table (User R-)   | R-/R-  PTSIZE
+ *    UVPT      ---->  +------------------------------+ 0xef400000
+ *                     |          RO PAGES            | R-/R-  PTSIZE
+ *    UPAGES    ---->  +------------------------------+ 0xef000000
+ *                     |           RO ENVS            | R-/R-  PTSIZE
+ * UTOP,UENVS ------>  +------------------------------+ 0xeec00000
+ * UXSTACKTOP -/       |     User Exception Stack     | RW/RW  PGSIZE
+ *                     +------------------------------+ 0xeebff000
+ *                     |       Empty Memory (*)       | --/--  PGSIZE
+ *    USTACKTOP  --->  +------------------------------+ 0xeebfe000
+ *                     |      Normal User Stack       | RW/RW  PGSIZE
+ *                     +------------------------------+ 0xeebfd000
+ *                     |                              |
+ *                     |                              |
+ *                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *                     .                              .
+ *                     .                              .
+ *                     .                              .
+ *                     |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~|
+ *                     |     Program Data & Heap      |
+ *    UTEXT -------->  +------------------------------+ 0x00800000
+ *    PFTEMP ------->  |       Empty Memory (*)       |        PTSIZE
+ *                     |                              |
+ *    UTEMP -------->  +------------------------------+ 0x00400000      --+
+ *                     |       Empty Memory (*)       |                   |
+ *                     | - - - - - - - - - - - - - - -|                   |
+ *                     |  User STAB Data (optional)   |                 PTSIZE
+ *    USTABDATA ---->  +------------------------------+ 0x00200000        |
+ *                     |       Empty Memory (*)       |                   |
+ *    0 ------------>  +------------------------------+                 --+
+ *
+ * (*) Note: The kernel ensures that "Invalid Memory" is *never* mapped.
+ *     "Empty Memory" is normally unmapped, but user programs may map pages
+ *     there if desired.  JOS user programs map pages temporarily at UTEMP.
+ */
+
+
+// All physical memory mapped at this address
+#define	KERNBASE	0xF0000000
+
+// At IOPHYSMEM (640K) there is a 384K hole for I/O.  From the kernel,
+// IOPHYSMEM can be addressed at KERNBASE + IOPHYSMEM.  The hole ends
+// at physical address EXTPHYSMEM.
+#define IOPHYSMEM	0x0A0000
+#define EXTPHYSMEM	0x100000
+
+// Kernel stack.
+#define KSTACKTOP	KERNBASE
+#define KSTKSIZE	(8*PGSIZE)   		// size of a kernel stack
+#define KSTKGAP		(8*PGSIZE)   		// size of a kernel stack guard
+
+// Memory-mapped IO.
+#define MMIOLIM		(KSTACKTOP - PTSIZE)
+#define MMIOBASE	(MMIOLIM - PTSIZE)
+
+#define ULIM		(MMIOBASE)
+
+/*
+ * User read-only mappings! Anything below here til UTOP are readonly to user.
+ * They are global pages mapped in at env allocation time.
+ */
+
+// User read-only virtual page table (see 'uvpt' below)
+#define UVPT		(ULIM - PTSIZE)
+// Read-only copies of the Page structures
+#define UPAGES		(UVPT - PTSIZE)
+// Read-only copies of the global env structures
+#define UENVS		(UPAGES - PTSIZE)
+
+/*
+ * Top of user VM. User can manipulate VA from UTOP-1 and down!
+ */
+
+// Top of user-accessible VM
+#define UTOP		UENVS
+// Top of one-page user exception stack
+#define UXSTACKTOP	UTOP
+// Next page left invalid to guard against exception stack overflow; then:
+// Top of normal user stack
+#define USTACKTOP	(UTOP - 2*PGSIZE)
+
+// Where user programs generally begin
+#define UTEXT		(2*PTSIZE)
+
+// Used for temporary page mappings.  Typed 'void*' for convenience
+#define UTEMP		((void*) PTSIZE)
+// Used for temporary page mappings for the user page-fault handler
+// (should not conflict with other temporary page mappings)
+#define PFTEMP		(UTEMP + PTSIZE - PGSIZE)
+// The location of the user-level STABS data structure
+#define USTABDATA	(PTSIZE / 2)
+
+#ifndef __ASSEMBLER__
+
+typedef uint32_t pte_t;
+typedef uint32_t pde_t;
+
+#endif /* !__ASSEMBLER__ */
+#endif /* !JOS_INC_MEMLAYOUT_H */
diff --git a/inc/mmu.h b/inc/mmu.h
new file mode 100644
index 0000000..093c8a6
--- /dev/null
+++ b/inc/mmu.h
@@ -0,0 +1,317 @@
+#ifndef JOS_INC_MMU_H
+#define JOS_INC_MMU_H
+
+/*
+ * This file contains definitions for the x86 memory management unit (MMU),
+ * including paging- and segmentation-related data structures and constants,
+ * the %cr0, %cr4, and %eflags registers, and traps.
+ */
+
+/*
+ *
+ *	Part 1.  Paging data structures and constants.
+ *
+ */
+
+// A linear address 'la' has a three-part structure as follows:
+//
+// +--------10------+-------10-------+---------12----------+
+// | Page Directory |   Page Table   | Offset within Page  |
+// |      Index     |      Index     |                     |
+// +----------------+----------------+---------------------+
+//  \--- PDX(la) --/ \--- PTX(la) --/ \---- PGOFF(la) ----/
+//  \---------- PGNUM(la) ----------/
+//
+// The PDX, PTX, PGOFF, and PGNUM macros decompose linear addresses as shown.
+// To construct a linear address la from PDX(la), PTX(la), and PGOFF(la),
+// use PGADDR(PDX(la), PTX(la), PGOFF(la)).
+
+// page number field of address
+#define PGNUM(la)	(((uintptr_t) (la)) >> PTXSHIFT)
+
+// page directory index
+#define PDX(la)		((((uintptr_t) (la)) >> PDXSHIFT) & 0x3FF)
+
+// page table index
+#define PTX(la)		((((uintptr_t) (la)) >> PTXSHIFT) & 0x3FF)
+
+// offset in page
+#define PGOFF(la)	(((uintptr_t) (la)) & 0xFFF)
+
+// construct linear address from indexes and offset
+#define PGADDR(d, t, o)	((void*) ((d) << PDXSHIFT | (t) << PTXSHIFT | (o)))
+
+// Page directory and page table constants.
+#define NPDENTRIES	1024		// page directory entries per page directory
+#define NPTENTRIES	1024		// page table entries per page table
+
+#define PGSIZE		4096		// bytes mapped by a page
+#define PGSHIFT		12		// log2(PGSIZE)
+
+#define PTSIZE		(PGSIZE*NPTENTRIES) // bytes mapped by a page directory entry
+#define PTSHIFT		22		// log2(PTSIZE)
+
+#define PTXSHIFT	12		// offset of PTX in a linear address
+#define PDXSHIFT	22		// offset of PDX in a linear address
+
+// Page table/directory entry flags.
+#define PTE_P		0x001	// Present
+#define PTE_W		0x002	// Writeable
+#define PTE_U		0x004	// User
+#define PTE_PWT		0x008	// Write-Through
+#define PTE_PCD		0x010	// Cache-Disable
+#define PTE_A		0x020	// Accessed
+#define PTE_D		0x040	// Dirty
+#define PTE_PS		0x080	// Page Size
+#define PTE_G		0x100	// Global
+
+// The PTE_AVAIL bits aren't used by the kernel or interpreted by the
+// hardware, so user processes are allowed to set them arbitrarily.
+#define PTE_AVAIL	0xE00	// Available for software use
+
+// Flags in PTE_SYSCALL may be used in system calls.  (Others may not.)
+#define PTE_SYSCALL	(PTE_AVAIL | PTE_P | PTE_W | PTE_U)
+
+// Address in page table or page directory entry
+#define PTE_ADDR(pte)	((physaddr_t) (pte) & ~0xFFF)
+
+// Control Register flags
+#define CR0_PE		0x00000001	// Protection Enable
+#define CR0_MP		0x00000002	// Monitor coProcessor
+#define CR0_EM		0x00000004	// Emulation
+#define CR0_TS		0x00000008	// Task Switched
+#define CR0_ET		0x00000010	// Extension Type
+#define CR0_NE		0x00000020	// Numeric Errror
+#define CR0_WP		0x00010000	// Write Protect
+#define CR0_AM		0x00040000	// Alignment Mask
+#define CR0_NW		0x20000000	// Not Writethrough
+#define CR0_CD		0x40000000	// Cache Disable
+#define CR0_PG		0x80000000	// Paging
+
+#define CR4_PCE		0x00000100	// Performance counter enable
+#define CR4_MCE		0x00000040	// Machine Check Enable
+#define CR4_PSE		0x00000010	// Page Size Extensions
+#define CR4_DE		0x00000008	// Debugging Extensions
+#define CR4_TSD		0x00000004	// Time Stamp Disable
+#define CR4_PVI		0x00000002	// Protected-Mode Virtual Interrupts
+#define CR4_VME		0x00000001	// V86 Mode Extensions
+
+// Eflags register
+#define FL_CF		0x00000001	// Carry Flag
+#define FL_PF		0x00000004	// Parity Flag
+#define FL_AF		0x00000010	// Auxiliary carry Flag
+#define FL_ZF		0x00000040	// Zero Flag
+#define FL_SF		0x00000080	// Sign Flag
+#define FL_TF		0x00000100	// Trap Flag
+#define FL_IF		0x00000200	// Interrupt Flag
+#define FL_DF		0x00000400	// Direction Flag
+#define FL_OF		0x00000800	// Overflow Flag
+#define FL_IOPL_MASK	0x00003000	// I/O Privilege Level bitmask
+#define FL_IOPL_0	0x00000000	//   IOPL == 0
+#define FL_IOPL_1	0x00001000	//   IOPL == 1
+#define FL_IOPL_2	0x00002000	//   IOPL == 2
+#define FL_IOPL_3	0x00003000	//   IOPL == 3
+#define FL_NT		0x00004000	// Nested Task
+#define FL_RF		0x00010000	// Resume Flag
+#define FL_VM		0x00020000	// Virtual 8086 mode
+#define FL_AC		0x00040000	// Alignment Check
+#define FL_VIF		0x00080000	// Virtual Interrupt Flag
+#define FL_VIP		0x00100000	// Virtual Interrupt Pending
+#define FL_ID		0x00200000	// ID flag
+
+// Page fault error codes
+#define FEC_PR		0x1	// Page fault caused by protection violation
+#define FEC_WR		0x2	// Page fault caused by a write
+#define FEC_U		0x4	// Page fault occured while in user mode
+
+
+/*
+ *
+ *	Part 2.  Segmentation data structures and constants.
+ *
+ */
+
+#ifdef __ASSEMBLER__
+
+/*
+ * Macros to build GDT entries in assembly.
+ */
+#define SEG_NULL						\
+	.word 0, 0;						\
+	.byte 0, 0, 0, 0
+#define SEG(type,base,lim)					\
+	.word (((lim) >> 12) & 0xffff), ((base) & 0xffff);	\
+	.byte (((base) >> 16) & 0xff), (0x90 | (type)),		\
+		(0xC0 | (((lim) >> 28) & 0xf)), (((base) >> 24) & 0xff)
+
+#else	// not __ASSEMBLER__
+
+#include <inc/types.h>
+
+// Segment Descriptors
+struct Segdesc {
+	unsigned sd_lim_15_0 : 16;  // Low bits of segment limit
+	unsigned sd_base_15_0 : 16; // Low bits of segment base address
+	unsigned sd_base_23_16 : 8; // Middle bits of segment base address
+	unsigned sd_type : 4;       // Segment type (see STS_ constants)
+	unsigned sd_s : 1;          // 0 = system, 1 = application
+	unsigned sd_dpl : 2;        // Descriptor Privilege Level
+	unsigned sd_p : 1;          // Present
+	unsigned sd_lim_19_16 : 4;  // High bits of segment limit
+	unsigned sd_avl : 1;        // Unused (available for software use)
+	unsigned sd_rsv1 : 1;       // Reserved
+	unsigned sd_db : 1;         // 0 = 16-bit segment, 1 = 32-bit segment
+	unsigned sd_g : 1;          // Granularity: limit scaled by 4K when set
+	unsigned sd_base_31_24 : 8; // High bits of segment base address
+};
+// Null segment
+#define SEG_NULL	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+// Segment that is loadable but faults when used
+#define SEG_FAULT	{ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 }
+// Normal segment
+#define SEG(type, base, lim, dpl) 					\
+{ ((lim) >> 12) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,	\
+    type, 1, dpl, 1, (unsigned) (lim) >> 28, 0, 0, 1, 1,		\
+    (unsigned) (base) >> 24 }
+#define SEG16(type, base, lim, dpl) (struct Segdesc)			\
+{ (lim) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,		\
+    type, 1, dpl, 1, (unsigned) (lim) >> 16, 0, 0, 1, 0,		\
+    (unsigned) (base) >> 24 }
+
+#endif /* !__ASSEMBLER__ */
+
+// Application segment type bits
+#define STA_X		0x8	    // Executable segment
+#define STA_E		0x4	    // Expand down (non-executable segments)
+#define STA_C		0x4	    // Conforming code segment (executable only)
+#define STA_W		0x2	    // Writeable (non-executable segments)
+#define STA_R		0x2	    // Readable (executable segments)
+#define STA_A		0x1	    // Accessed
+
+// System segment type bits
+#define STS_T16A	0x1	    // Available 16-bit TSS
+#define STS_LDT		0x2	    // Local Descriptor Table
+#define STS_T16B	0x3	    // Busy 16-bit TSS
+#define STS_CG16	0x4	    // 16-bit Call Gate
+#define STS_TG		0x5	    // Task Gate / Coum Transmitions
+#define STS_IG16	0x6	    // 16-bit Interrupt Gate
+#define STS_TG16	0x7	    // 16-bit Trap Gate
+#define STS_T32A	0x9	    // Available 32-bit TSS
+#define STS_T32B	0xB	    // Busy 32-bit TSS
+#define STS_CG32	0xC	    // 32-bit Call Gate
+#define STS_IG32	0xE	    // 32-bit Interrupt Gate
+#define STS_TG32	0xF	    // 32-bit Trap Gate
+
+
+/*
+ *
+ *	Part 3.  Traps.
+ *
+ */
+
+#ifndef __ASSEMBLER__
+
+// Task state segment format (as described by the Pentium architecture book)
+struct Taskstate {
+	uint32_t ts_link;	// Old ts selector
+	uintptr_t ts_esp0;	// Stack pointers and segment selectors
+	uint16_t ts_ss0;	//   after an increase in privilege level
+	uint16_t ts_padding1;
+	uintptr_t ts_esp1;
+	uint16_t ts_ss1;
+	uint16_t ts_padding2;
+	uintptr_t ts_esp2;
+	uint16_t ts_ss2;
+	uint16_t ts_padding3;
+	physaddr_t ts_cr3;	// Page directory base
+	uintptr_t ts_eip;	// Saved state from last task switch
+	uint32_t ts_eflags;
+	uint32_t ts_eax;	// More saved state (registers)
+	uint32_t ts_ecx;
+	uint32_t ts_edx;
+	uint32_t ts_ebx;
+	uintptr_t ts_esp;
+	uintptr_t ts_ebp;
+	uint32_t ts_esi;
+	uint32_t ts_edi;
+	uint16_t ts_es;		// Even more saved state (segment selectors)
+	uint16_t ts_padding4;
+	uint16_t ts_cs;
+	uint16_t ts_padding5;
+	uint16_t ts_ss;
+	uint16_t ts_padding6;
+	uint16_t ts_ds;
+	uint16_t ts_padding7;
+	uint16_t ts_fs;
+	uint16_t ts_padding8;
+	uint16_t ts_gs;
+	uint16_t ts_padding9;
+	uint16_t ts_ldt;
+	uint16_t ts_padding10;
+	uint16_t ts_t;		// Trap on task switch
+	uint16_t ts_iomb;	// I/O map base address
+};
+
+// Gate descriptors for interrupts and traps
+struct Gatedesc {
+	unsigned gd_off_15_0 : 16;   // low 16 bits of offset in segment
+	unsigned gd_sel : 16;        // segment selector
+	unsigned gd_args : 5;        // # args, 0 for interrupt/trap gates
+	unsigned gd_rsv1 : 3;        // reserved(should be zero I guess)
+	unsigned gd_type : 4;        // type(STS_{TG,IG32,TG32})
+	unsigned gd_s : 1;           // must be 0 (system)
+	unsigned gd_dpl : 2;         // descriptor(meaning new) privilege level
+	unsigned gd_p : 1;           // Present
+	unsigned gd_off_31_16 : 16;  // high bits of offset in segment
+};
+
+// Set up a normal interrupt/trap gate descriptor.
+// - istrap: 1 for a trap (= exception) gate, 0 for an interrupt gate.
+    //   see section 9.6.1.3 of the i386 reference: "The difference between
+    //   an interrupt gate and a trap gate is in the effect on IF (the
+    //   interrupt-enable flag). An interrupt that vectors through an
+    //   interrupt gate resets IF, thereby preventing other interrupts from
+    //   interfering with the current interrupt handler. A subsequent IRET
+    //   instruction restores IF to the value in the EFLAGS image on the
+    //   stack. An interrupt through a trap gate does not change IF."
+// - sel: Code segment selector for interrupt/trap handler
+// - off: Offset in code segment for interrupt/trap handler
+// - dpl: Descriptor Privilege Level -
+//	  the privilege level required for software to invoke
+//	  this interrupt/trap gate explicitly using an int instruction.
+#define SETGATE(gate, istrap, sel, off, dpl)			\
+{								\
+	(gate).gd_off_15_0 = (uint32_t) (off) & 0xffff;		\
+	(gate).gd_sel = (sel);					\
+	(gate).gd_args = 0;					\
+	(gate).gd_rsv1 = 0;					\
+	(gate).gd_type = (istrap) ? STS_TG32 : STS_IG32;	\
+	(gate).gd_s = 0;					\
+	(gate).gd_dpl = (dpl);					\
+	(gate).gd_p = 1;					\
+	(gate).gd_off_31_16 = (uint32_t) (off) >> 16;		\
+}
+
+// Set up a call gate descriptor.
+#define SETCALLGATE(gate, sel, off, dpl)           	        \
+{								\
+	(gate).gd_off_15_0 = (uint32_t) (off) & 0xffff;		\
+	(gate).gd_sel = (sel);					\
+	(gate).gd_args = 0;					\
+	(gate).gd_rsv1 = 0;					\
+	(gate).gd_type = STS_CG32;				\
+	(gate).gd_s = 0;					\
+	(gate).gd_dpl = (dpl);					\
+	(gate).gd_p = 1;					\
+	(gate).gd_off_31_16 = (uint32_t) (off) >> 16;		\
+}
+
+// Pseudo-descriptors used for LGDT, LLDT and LIDT instructions.
+struct Pseudodesc {
+	uint16_t pd_lim;		// Limit
+	uint32_t pd_base;		// Base address
+} __attribute__ ((packed));
+
+#endif /* !__ASSEMBLER__ */
+
+#endif /* !JOS_INC_MMU_H */
diff --git a/inc/stab.h b/inc/stab.h
new file mode 100644
index 0000000..8153cec
--- /dev/null
+++ b/inc/stab.h
@@ -0,0 +1,51 @@
+#ifndef JOS_STAB_H
+#define JOS_STAB_H
+#include <inc/types.h>
+
+// <inc/stab.h>
+// STABS debugging info
+
+// The JOS kernel debugger can understand some debugging information
+// in the STABS format.  For more information on this format, see
+// http://sourceware.org/gdb/onlinedocs/stabs.html
+
+// The constants below define some symbol types used by various debuggers
+// and compilers.  JOS uses the N_SO, N_SOL, N_FUN, and N_SLINE types.
+
+#define	N_GSYM		0x20	// global symbol
+#define	N_FNAME		0x22	// F77 function name
+#define	N_FUN		0x24	// procedure name
+#define	N_STSYM		0x26	// data segment variable
+#define	N_LCSYM		0x28	// bss segment variable
+#define	N_MAIN		0x2a	// main function name
+#define	N_PC		0x30	// global Pascal symbol
+#define	N_RSYM		0x40	// register variable
+#define	N_SLINE		0x44	// text segment line number
+#define	N_DSLINE	0x46	// data segment line number
+#define	N_BSLINE	0x48	// bss segment line number
+#define	N_SSYM		0x60	// structure/union element
+#define	N_SO		0x64	// main source file name
+#define	N_LSYM		0x80	// stack variable
+#define	N_BINCL		0x82	// include file beginning
+#define	N_SOL		0x84	// included source file name
+#define	N_PSYM		0xa0	// parameter variable
+#define	N_EINCL		0xa2	// include file end
+#define	N_ENTRY		0xa4	// alternate entry point
+#define	N_LBRAC		0xc0	// left bracket
+#define	N_EXCL		0xc2	// deleted include file
+#define	N_RBRAC		0xe0	// right bracket
+#define	N_BCOMM		0xe2	// begin common
+#define	N_ECOMM		0xe4	// end common
+#define	N_ECOML		0xe8	// end common (local name)
+#define	N_LENG		0xfe	// length of preceding entry
+
+// Entries in the STABS table are formatted as follows.
+struct Stab {
+	uint32_t n_strx;	// index into string table of name
+	uint8_t n_type;         // type of symbol
+	uint8_t n_other;        // misc info (usually empty)
+	uint16_t n_desc;        // description field
+	uintptr_t n_value;	// value of symbol
+};
+
+#endif /* !JOS_STAB_H */
diff --git a/inc/stdarg.h b/inc/stdarg.h
new file mode 100644
index 0000000..cf8d814
--- /dev/null
+++ b/inc/stdarg.h
@@ -0,0 +1,14 @@
+/*	$NetBSD: stdarg.h,v 1.12 1995/12/25 23:15:31 mycroft Exp $	*/
+
+#ifndef JOS_INC_STDARG_H
+#define	JOS_INC_STDARG_H
+
+typedef __builtin_va_list va_list;
+
+#define va_start(ap, last) __builtin_va_start(ap, last)
+
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+
+#define va_end(ap) __builtin_va_end(ap)
+
+#endif	/* !JOS_INC_STDARG_H */
diff --git a/inc/stdio.h b/inc/stdio.h
new file mode 100644
index 0000000..a44b491
--- /dev/null
+++ b/inc/stdio.h
@@ -0,0 +1,33 @@
+#ifndef JOS_INC_STDIO_H
+#define JOS_INC_STDIO_H
+
+#include <inc/stdarg.h>
+
+#ifndef NULL
+#define NULL	((void *) 0)
+#endif /* !NULL */
+
+// lib/console.c
+void	cputchar(int c);
+int	getchar(void);
+int	iscons(int fd);
+
+// lib/printfmt.c
+void	printfmt(void (*putch)(int, void*), void *putdat, const char *fmt, ...);
+void	vprintfmt(void (*putch)(int, void*), void *putdat, const char *fmt, va_list);
+int	snprintf(char *str, int size, const char *fmt, ...);
+int	vsnprintf(char *str, int size, const char *fmt, va_list);
+
+// lib/printf.c
+int	cprintf(const char *fmt, ...);
+int	vcprintf(const char *fmt, va_list);
+
+// lib/fprintf.c
+int	printf(const char *fmt, ...);
+int	fprintf(int fd, const char *fmt, ...);
+int	vfprintf(int fd, const char *fmt, va_list);
+
+// lib/readline.c
+char*	readline(const char *prompt);
+
+#endif /* !JOS_INC_STDIO_H */
diff --git a/inc/string.h b/inc/string.h
new file mode 100644
index 0000000..4a30c96
--- /dev/null
+++ b/inc/string.h
@@ -0,0 +1,25 @@
+#ifndef JOS_INC_STRING_H
+#define JOS_INC_STRING_H
+
+#include <inc/types.h>
+
+int	strlen(const char *s);
+int	strnlen(const char *s, size_t size);
+char *	strcpy(char *dst, const char *src);
+char *	strncpy(char *dst, const char *src, size_t size);
+char *	strcat(char *dst, const char *src);
+size_t	strlcpy(char *dst, const char *src, size_t size);
+int	strcmp(const char *s1, const char *s2);
+int	strncmp(const char *s1, const char *s2, size_t size);
+char *	strchr(const char *s, char c);
+char *	strfind(const char *s, char c);
+
+void *	memset(void *dst, int c, size_t len);
+void *	memcpy(void *dst, const void *src, size_t len);
+void *	memmove(void *dst, const void *src, size_t len);
+int	memcmp(const void *s1, const void *s2, size_t len);
+void *	memfind(const void *s, int c, size_t len);
+
+long	strtol(const char *s, char **endptr, int base);
+
+#endif /* not JOS_INC_STRING_H */
diff --git a/inc/types.h b/inc/types.h
new file mode 100644
index 0000000..c016708
--- /dev/null
+++ b/inc/types.h
@@ -0,0 +1,75 @@
+#ifndef JOS_INC_TYPES_H
+#define JOS_INC_TYPES_H
+
+#ifndef NULL
+#define NULL ((void*) 0)
+#endif
+
+// Represents true-or-false values
+typedef _Bool bool;
+enum { false, true };
+
+// Explicitly-sized versions of integer types
+typedef __signed char int8_t;
+typedef unsigned char uint8_t;
+typedef short int16_t;
+typedef unsigned short uint16_t;
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef long long int64_t;
+typedef unsigned long long uint64_t;
+
+// Pointers and addresses are 32 bits long.
+// We use pointer types to represent virtual addresses,
+// uintptr_t to represent the numerical values of virtual addresses,
+// and physaddr_t to represent physical addresses.
+typedef int32_t intptr_t;
+typedef uint32_t uintptr_t;
+typedef uint32_t physaddr_t;
+
+// Page numbers are 32 bits long.
+typedef uint32_t ppn_t;
+
+// size_t is used for memory object sizes.
+typedef uint32_t size_t;
+// ssize_t is a signed version of ssize_t, used in case there might be an
+// error return.
+typedef int32_t ssize_t;
+
+// off_t is used for file offsets and lengths.
+typedef int32_t off_t;
+
+// Efficient min and max operations
+#define MIN(_a, _b)						\
+({								\
+	typeof(_a) __a = (_a);					\
+	typeof(_b) __b = (_b);					\
+	__a <= __b ? __a : __b;					\
+})
+#define MAX(_a, _b)						\
+({								\
+	typeof(_a) __a = (_a);					\
+	typeof(_b) __b = (_b);					\
+	__a >= __b ? __a : __b;					\
+})
+
+// Rounding operations (efficient when n is a power of 2)
+// Round down to the nearest multiple of n
+#define ROUNDDOWN(a, n)						\
+({								\
+	uint32_t __a = (uint32_t) (a);				\
+	(typeof(a)) (__a - __a % (n));				\
+})
+// Round up to the nearest multiple of n
+#define ROUNDUP(a, n)						\
+({								\
+	uint32_t __n = (uint32_t) (n);				\
+	(typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n));	\
+})
+
+#define ARRAY_SIZE(a)	(sizeof(a) / sizeof(a[0]))
+
+// Return the offset of 'member' relative to the beginning of a struct type
+#define offsetof(type, member)  ((size_t) (&((type*)0)->member))
+
+#endif /* !JOS_INC_TYPES_H */
diff --git a/inc/x86.h b/inc/x86.h
new file mode 100644
index 0000000..cc15ff4
--- /dev/null
+++ b/inc/x86.h
@@ -0,0 +1,264 @@
+#ifndef JOS_INC_X86_H
+#define JOS_INC_X86_H
+
+#include <inc/types.h>
+
+static inline void
+breakpoint(void)
+{
+	asm volatile("int3");
+}
+
+static inline uint8_t
+inb(int port)
+{
+	uint8_t data;
+	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
+	return data;
+}
+
+static inline void
+insb(int port, void *addr, int cnt)
+{
+	asm volatile("cld\n\trepne\n\tinsb"
+		     : "=D" (addr), "=c" (cnt)
+		     : "d" (port), "0" (addr), "1" (cnt)
+		     : "memory", "cc");
+}
+
+static inline uint16_t
+inw(int port)
+{
+	uint16_t data;
+	asm volatile("inw %w1,%0" : "=a" (data) : "d" (port));
+	return data;
+}
+
+static inline void
+insw(int port, void *addr, int cnt)
+{
+	asm volatile("cld\n\trepne\n\tinsw"
+		     : "=D" (addr), "=c" (cnt)
+		     : "d" (port), "0" (addr), "1" (cnt)
+		     : "memory", "cc");
+}
+
+static inline uint32_t
+inl(int port)
+{
+	uint32_t data;
+	asm volatile("inl %w1,%0" : "=a" (data) : "d" (port));
+	return data;
+}
+
+static inline void
+insl(int port, void *addr, int cnt)
+{
+	asm volatile("cld\n\trepne\n\tinsl"
+		     : "=D" (addr), "=c" (cnt)
+		     : "d" (port), "0" (addr), "1" (cnt)
+		     : "memory", "cc");
+}
+
+static inline void
+outb(int port, uint8_t data)
+{
+	asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
+}
+
+static inline void
+outsb(int port, const void *addr, int cnt)
+{
+	asm volatile("cld\n\trepne\n\toutsb"
+		     : "=S" (addr), "=c" (cnt)
+		     : "d" (port), "0" (addr), "1" (cnt)
+		     : "cc");
+}
+
+static inline void
+outw(int port, uint16_t data)
+{
+	asm volatile("outw %0,%w1" : : "a" (data), "d" (port));
+}
+
+static inline void
+outsw(int port, const void *addr, int cnt)
+{
+	asm volatile("cld\n\trepne\n\toutsw"
+		     : "=S" (addr), "=c" (cnt)
+		     : "d" (port), "0" (addr), "1" (cnt)
+		     : "cc");
+}
+
+static inline void
+outsl(int port, const void *addr, int cnt)
+{
+	asm volatile("cld\n\trepne\n\toutsl"
+		     : "=S" (addr), "=c" (cnt)
+		     : "d" (port), "0" (addr), "1" (cnt)
+		     : "cc");
+}
+
+static inline void
+outl(int port, uint32_t data)
+{
+	asm volatile("outl %0,%w1" : : "a" (data), "d" (port));
+}
+
+static inline void
+invlpg(void *addr)
+{
+	asm volatile("invlpg (%0)" : : "r" (addr) : "memory");
+}
+
+static inline void
+lidt(void *p)
+{
+	asm volatile("lidt (%0)" : : "r" (p));
+}
+
+static inline void
+lgdt(void *p)
+{
+	asm volatile("lgdt (%0)" : : "r" (p));
+}
+
+static inline void
+lldt(uint16_t sel)
+{
+	asm volatile("lldt %0" : : "r" (sel));
+}
+
+static inline void
+ltr(uint16_t sel)
+{
+	asm volatile("ltr %0" : : "r" (sel));
+}
+
+static inline void
+lcr0(uint32_t val)
+{
+	asm volatile("movl %0,%%cr0" : : "r" (val));
+}
+
+static inline uint32_t
+rcr0(void)
+{
+	uint32_t val;
+	asm volatile("movl %%cr0,%0" : "=r" (val));
+	return val;
+}
+
+static inline uint32_t
+rcr2(void)
+{
+	uint32_t val;
+	asm volatile("movl %%cr2,%0" : "=r" (val));
+	return val;
+}
+
+static inline void
+lcr3(uint32_t val)
+{
+	asm volatile("movl %0,%%cr3" : : "r" (val));
+}
+
+static inline uint32_t
+rcr3(void)
+{
+	uint32_t val;
+	asm volatile("movl %%cr3,%0" : "=r" (val));
+	return val;
+}
+
+static inline void
+lcr4(uint32_t val)
+{
+	asm volatile("movl %0,%%cr4" : : "r" (val));
+}
+
+static inline uint32_t
+rcr4(void)
+{
+	uint32_t cr4;
+	asm volatile("movl %%cr4,%0" : "=r" (cr4));
+	return cr4;
+}
+
+static inline void
+tlbflush(void)
+{
+	uint32_t cr3;
+	asm volatile("movl %%cr3,%0" : "=r" (cr3));
+	asm volatile("movl %0,%%cr3" : : "r" (cr3));
+}
+
+static inline uint32_t
+read_eflags(void)
+{
+	uint32_t eflags;
+	asm volatile("pushfl; popl %0" : "=r" (eflags));
+	return eflags;
+}
+
+static inline void
+write_eflags(uint32_t eflags)
+{
+	asm volatile("pushl %0; popfl" : : "r" (eflags));
+}
+
+static inline uint32_t
+read_ebp(void)
+{
+	uint32_t ebp;
+	asm volatile("movl %%ebp,%0" : "=r" (ebp));
+	return ebp;
+}
+
+static inline uint32_t
+read_esp(void)
+{
+	uint32_t esp;
+	asm volatile("movl %%esp,%0" : "=r" (esp));
+	return esp;
+}
+
+static inline void
+cpuid(uint32_t info, uint32_t *eaxp, uint32_t *ebxp, uint32_t *ecxp, uint32_t *edxp)
+{
+	uint32_t eax, ebx, ecx, edx;
+	asm volatile("cpuid"
+		     : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
+		     : "a" (info));
+	if (eaxp)
+		*eaxp = eax;
+	if (ebxp)
+		*ebxp = ebx;
+	if (ecxp)
+		*ecxp = ecx;
+	if (edxp)
+		*edxp = edx;
+}
+
+static inline uint64_t
+read_tsc(void)
+{
+	uint64_t tsc;
+	asm volatile("rdtsc" : "=A" (tsc));
+	return tsc;
+}
+
+static inline uint32_t
+xchg(volatile uint32_t *addr, uint32_t newval)
+{
+	uint32_t result;
+
+	// The + in "+m" denotes a read-modify-write operand.
+	asm volatile("lock; xchgl %0, %1"
+		     : "+m" (*addr), "=a" (result)
+		     : "1" (newval)
+		     : "cc");
+	return result;
+}
+
+#endif /* !JOS_INC_X86_H */
diff --git a/kern/COPYRIGHT b/kern/COPYRIGHT
new file mode 100644
index 0000000..6a0270c
--- /dev/null
+++ b/kern/COPYRIGHT
@@ -0,0 +1,155 @@
+Most of the source files in this directory are derived from the Exokernel,
+which is:
+
+/*
+ * Copyright (C) 1997 Massachusetts Institute of Technology 
+ *
+ * This software is being provided by the copyright holders under the
+ * following license. By obtaining, using and/or copying this software,
+ * you agree that you have read, understood, and will comply with the
+ * following terms and conditions:
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose and without fee or royalty is
+ * hereby granted, provided that the full text of this NOTICE appears on
+ * ALL copies of the software and documentation or portions thereof,
+ * including modifications, that you make.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO
+ * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
+ * BUT NOT LIMITATION, COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR
+ * WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR
+ * THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY
+ * THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. COPYRIGHT
+ * HOLDERS WILL BEAR NO LIABILITY FOR ANY USE OF THIS SOFTWARE OR
+ * DOCUMENTATION.
+ *
+ * The name and trademarks of copyright holders may NOT be used in
+ * advertising or publicity pertaining to the software without specific,
+ * written prior permission. Title to copyright in this software and any
+ * associated documentation will at all times remain with copyright
+ * holders. See the file AUTHORS which should have accompanied this software
+ * for a list of all copyright holders.
+ *
+ * This file may be derived from previously copyrighted software. This
+ * copyright applies only to those changes made by the copyright
+ * holders listed in the AUTHORS file. The rest of this file is covered by
+ * the copyright notices, if any, listed below.
+ */
+
+Console.c was created consulting the NetBSD pccons driver which is:
+
+/*-
+ * Copyright (c) 1993, 1994, 1995 Charles Hannum.  All rights reserved.
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * William Jolitz and Don Ahn.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+Kclock.h, sched.h, and printf.h are copyright:
+
+/*
+ * Copyright (C) 1998 Exotec, Inc.
+ *
+ * This software is being provided by the copyright holders under the
+ * following license. By obtaining, using and/or copying this software,
+ * you agree that you have read, understood, and will comply with the
+ * following terms and conditions:
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose and without fee or royalty is
+ * hereby granted, provided that the full text of this NOTICE appears on
+ * ALL copies of the software and documentation or portions thereof,
+ * including modifications, that you make.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO
+ * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
+ * BUT NOT LIMITATION, COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR
+ * WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR
+ * THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY
+ * THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. COPYRIGHT
+ * HOLDERS WILL BEAR NO LIABILITY FOR ANY USE OF THIS SOFTWARE OR
+ * DOCUMENTATION.
+ *
+ * The name and trademarks of copyright holders may NOT be used in
+ * advertising or publicity pertaining to the software without specific,
+ * written prior permission. Title to copyright in this software and any
+ * associated documentation will at all times remain with Exotec, Inc..
+ *
+ * This file may be derived from previously copyrighted software. This
+ * copyright applies only to those changes made by Exotec, Inc. The rest
+ * of this file is covered by the copyright notices, if any, listed below.
+ */
+
+Printf.c is copyright:
+
+/*-
+ * Copyright (c) 1986, 1988, 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)subr_prf.c	8.3 (Berkeley) 1/21/94
+ */
+
diff --git a/kern/Makefrag b/kern/Makefrag
new file mode 100644
index 0000000..3b2982e
--- /dev/null
+++ b/kern/Makefrag
@@ -0,0 +1,89 @@
+#
+# Makefile fragment for JOS kernel.
+# This is NOT a complete makefile;
+# you must run GNU make in the top-level directory
+# where the GNUmakefile is located.
+#
+
+OBJDIRS += kern
+
+KERN_LDFLAGS := $(LDFLAGS) -T kern/kernel.ld -nostdlib
+
+# entry.S must be first, so that it's the first code in the text segment!!!
+#
+# We also snatch the use of a couple handy source files
+# from the lib directory, to avoid gratuitous code duplication.
+KERN_SRCFILES :=	kern/entry.S \
+			kern/entrypgdir.c \
+			kern/init.c \
+			kern/console.c \
+			kern/monitor.c \
+			kern/pmap.c \
+			kern/env.c \
+			kern/kclock.c \
+			kern/picirq.c \
+			kern/printf.c \
+			kern/trap.c \
+			kern/trapentry.S \
+			kern/sched.c \
+			kern/syscall.c \
+			kern/kdebug.c \
+			lib/printfmt.c \
+			lib/readline.c \
+			lib/string.c
+
+# Only build files if they exist.
+KERN_SRCFILES := $(wildcard $(KERN_SRCFILES))
+
+# Binary program images to embed within the kernel.
+KERN_BINFILES := 
+
+KERN_OBJFILES := $(patsubst %.c, $(OBJDIR)/%.o, $(KERN_SRCFILES))
+KERN_OBJFILES := $(patsubst %.S, $(OBJDIR)/%.o, $(KERN_OBJFILES))
+KERN_OBJFILES := $(patsubst $(OBJDIR)/lib/%, $(OBJDIR)/kern/%, $(KERN_OBJFILES))
+
+KERN_BINFILES := $(patsubst %, $(OBJDIR)/%, $(KERN_BINFILES))
+
+# How to build kernel object files
+$(OBJDIR)/kern/%.o: kern/%.c $(OBJDIR)/.vars.KERN_CFLAGS
+	@echo + cc $<
+	@mkdir -p $(@D)
+	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -c -o $@ $<
+
+$(OBJDIR)/kern/%.o: kern/%.S $(OBJDIR)/.vars.KERN_CFLAGS
+	@echo + as $<
+	@mkdir -p $(@D)
+	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -c -o $@ $<
+
+$(OBJDIR)/kern/%.o: lib/%.c $(OBJDIR)/.vars.KERN_CFLAGS
+	@echo + cc $<
+	@mkdir -p $(@D)
+	$(V)$(CC) -nostdinc $(KERN_CFLAGS) -c -o $@ $<
+
+# Special flags for kern/init
+$(OBJDIR)/kern/init.o: override KERN_CFLAGS+=$(INIT_CFLAGS)
+$(OBJDIR)/kern/init.o: $(OBJDIR)/.vars.INIT_CFLAGS
+
+# How to build the kernel itself
+$(OBJDIR)/kern/kernel: $(KERN_OBJFILES) $(KERN_BINFILES) kern/kernel.ld \
+	  $(OBJDIR)/.vars.KERN_LDFLAGS
+	@echo + ld $@
+	$(V)$(LD) -o $@ $(KERN_LDFLAGS) $(KERN_OBJFILES) $(GCC_LIB) -b binary $(KERN_BINFILES)
+	$(V)$(OBJDUMP) -S $@ > $@.asm
+	$(V)$(NM) -n $@ > $@.sym
+
+# How to build the kernel disk image
+$(OBJDIR)/kern/kernel.img: $(OBJDIR)/kern/kernel $(OBJDIR)/boot/boot
+	@echo + mk $@
+	$(V)dd if=/dev/zero of=$(OBJDIR)/kern/kernel.img~ count=10000 2>/dev/null
+	$(V)dd if=$(OBJDIR)/boot/boot of=$(OBJDIR)/kern/kernel.img~ conv=notrunc 2>/dev/null
+	$(V)dd if=$(OBJDIR)/kern/kernel of=$(OBJDIR)/kern/kernel.img~ seek=1 conv=notrunc 2>/dev/null
+	$(V)mv $(OBJDIR)/kern/kernel.img~ $(OBJDIR)/kern/kernel.img
+
+all: $(OBJDIR)/kern/kernel.img
+
+grub: $(OBJDIR)/jos-grub
+
+$(OBJDIR)/jos-grub: $(OBJDIR)/kern/kernel
+	@echo + oc $@
+	$(V)$(OBJCOPY) --adjust-vma=0x10000000 $^ $@
diff --git a/kern/console.c b/kern/console.c
new file mode 100644
index 0000000..7d312a7
--- /dev/null
+++ b/kern/console.c
@@ -0,0 +1,476 @@
+/* See COPYRIGHT for copyright information. */
+
+#include <inc/x86.h>
+#include <inc/memlayout.h>
+#include <inc/kbdreg.h>
+#include <inc/string.h>
+#include <inc/assert.h>
+
+#include <kern/console.h>
+
+static void cons_intr(int (*proc)(void));
+static void cons_putc(int c);
+
+// Stupid I/O delay routine necessitated by historical PC design flaws
+static void
+delay(void)
+{
+	inb(0x84);
+	inb(0x84);
+	inb(0x84);
+	inb(0x84);
+}
+
+/***** Serial I/O code *****/
+
+#define COM1		0x3F8
+
+#define COM_RX		0	// In:	Receive buffer (DLAB=0)
+#define COM_TX		0	// Out: Transmit buffer (DLAB=0)
+#define COM_DLL		0	// Out: Divisor Latch Low (DLAB=1)
+#define COM_DLM		1	// Out: Divisor Latch High (DLAB=1)
+#define COM_IER		1	// Out: Interrupt Enable Register
+#define   COM_IER_RDI	0x01	//   Enable receiver data interrupt
+#define COM_IIR		2	// In:	Interrupt ID Register
+#define COM_FCR		2	// Out: FIFO Control Register
+#define COM_LCR		3	// Out: Line Control Register
+#define	  COM_LCR_DLAB	0x80	//   Divisor latch access bit
+#define	  COM_LCR_WLEN8	0x03	//   Wordlength: 8 bits
+#define COM_MCR		4	// Out: Modem Control Register
+#define	  COM_MCR_RTS	0x02	// RTS complement
+#define	  COM_MCR_DTR	0x01	// DTR complement
+#define	  COM_MCR_OUT2	0x08	// Out2 complement
+#define COM_LSR		5	// In:	Line Status Register
+#define   COM_LSR_DATA	0x01	//   Data available
+#define   COM_LSR_TXRDY	0x20	//   Transmit buffer avail
+#define   COM_LSR_TSRE	0x40	//   Transmitter off
+
+static bool serial_exists;
+
+static int
+serial_proc_data(void)
+{
+	if (!(inb(COM1+COM_LSR) & COM_LSR_DATA))
+		return -1;
+	return inb(COM1+COM_RX);
+}
+
+void
+serial_intr(void)
+{
+	if (serial_exists)
+		cons_intr(serial_proc_data);
+}
+
+static void
+serial_putc(int c)
+{
+	int i;
+
+	for (i = 0;
+	     !(inb(COM1 + COM_LSR) & COM_LSR_TXRDY) && i < 12800;
+	     i++)
+		delay();
+
+	outb(COM1 + COM_TX, c);
+}
+
+static void
+serial_init(void)
+{
+	// Turn off the FIFO
+	outb(COM1+COM_FCR, 0);
+
+	// Set speed; requires DLAB latch
+	outb(COM1+COM_LCR, COM_LCR_DLAB);
+	outb(COM1+COM_DLL, (uint8_t) (115200 / 9600));
+	outb(COM1+COM_DLM, 0);
+
+	// 8 data bits, 1 stop bit, parity off; turn off DLAB latch
+	outb(COM1+COM_LCR, COM_LCR_WLEN8 & ~COM_LCR_DLAB);
+
+	// No modem controls
+	outb(COM1+COM_MCR, 0);
+	// Enable rcv interrupts
+	outb(COM1+COM_IER, COM_IER_RDI);
+
+	// Clear any preexisting overrun indications and interrupts
+	// Serial port doesn't exist if COM_LSR returns 0xFF
+	serial_exists = (inb(COM1+COM_LSR) != 0xFF);
+	(void) inb(COM1+COM_IIR);
+	(void) inb(COM1+COM_RX);
+
+}
+
+
+
+/***** Parallel port output code *****/
+// For information on PC parallel port programming, see the class References
+// page.
+
+static void
+lpt_putc(int c)
+{
+	int i;
+
+	for (i = 0; !(inb(0x378+1) & 0x80) && i < 12800; i++)
+		delay();
+	outb(0x378+0, c);
+	outb(0x378+2, 0x08|0x04|0x01);
+	outb(0x378+2, 0x08);
+}
+
+
+
+
+/***** Text-mode CGA/VGA display output *****/
+
+static unsigned addr_6845;
+static uint16_t *crt_buf;
+static uint16_t crt_pos;
+
+static void
+cga_init(void)
+{
+	volatile uint16_t *cp;
+	uint16_t was;
+	unsigned pos;
+
+	cp = (uint16_t*) (KERNBASE + CGA_BUF);
+	was = *cp;
+	*cp = (uint16_t) 0xA55A;
+	if (*cp != 0xA55A) {
+		cp = (uint16_t*) (KERNBASE + MONO_BUF);
+		addr_6845 = MONO_BASE;
+	} else {
+		*cp = was;
+		addr_6845 = CGA_BASE;
+	}
+
+	/* Extract cursor location */
+	outb(addr_6845, 14);
+	pos = inb(addr_6845 + 1) << 8;
+	outb(addr_6845, 15);
+	pos |= inb(addr_6845 + 1);
+
+	crt_buf = (uint16_t*) cp;
+	crt_pos = pos;
+}
+
+
+
+static void
+cga_putc(int c)
+{
+	// if no attribute given, then use black on white
+	if (!(c & ~0xFF))
+		c |= 0x0700;
+
+	switch (c & 0xff) {
+	case '\b':
+		if (crt_pos > 0) {
+			crt_pos--;
+			crt_buf[crt_pos] = (c & ~0xff) | ' ';
+		}
+		break;
+	case '\n':
+		crt_pos += CRT_COLS;
+		/* fallthru */
+	case '\r':
+		crt_pos -= (crt_pos % CRT_COLS);
+		break;
+	case '\t':
+		cons_putc(' ');
+		cons_putc(' ');
+		cons_putc(' ');
+		cons_putc(' ');
+		cons_putc(' ');
+		break;
+	default:
+		crt_buf[crt_pos++] = c;		/* write the character */
+		break;
+	}
+
+	// What is the purpose of this?
+	if (crt_pos >= CRT_SIZE) {
+		int i;
+
+		memmove(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
+		for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i++)
+			crt_buf[i] = 0x0700 | ' ';
+		crt_pos -= CRT_COLS;
+	}
+
+	/* move that little blinky thing */
+	outb(addr_6845, 14);
+	outb(addr_6845 + 1, crt_pos >> 8);
+	outb(addr_6845, 15);
+	outb(addr_6845 + 1, crt_pos);
+}
+
+
+/***** Keyboard input code *****/
+
+#define NO		0
+
+#define SHIFT		(1<<0)
+#define CTL		(1<<1)
+#define ALT		(1<<2)
+
+#define CAPSLOCK	(1<<3)
+#define NUMLOCK		(1<<4)
+#define SCROLLLOCK	(1<<5)
+
+#define E0ESC		(1<<6)
+
+static uint8_t shiftcode[256] =
+{
+	[0x1D] = CTL,
+	[0x2A] = SHIFT,
+	[0x36] = SHIFT,
+	[0x38] = ALT,
+	[0x9D] = CTL,
+	[0xB8] = ALT
+};
+
+static uint8_t togglecode[256] =
+{
+	[0x3A] = CAPSLOCK,
+	[0x45] = NUMLOCK,
+	[0x46] = SCROLLLOCK
+};
+
+static uint8_t normalmap[256] =
+{
+	NO,   0x1B, '1',  '2',  '3',  '4',  '5',  '6',	// 0x00
+	'7',  '8',  '9',  '0',  '-',  '=',  '\b', '\t',
+	'q',  'w',  'e',  'r',  't',  'y',  'u',  'i',	// 0x10
+	'o',  'p',  '[',  ']',  '\n', NO,   'a',  's',
+	'd',  'f',  'g',  'h',  'j',  'k',  'l',  ';',	// 0x20
+	'\'', '`',  NO,   '\\', 'z',  'x',  'c',  'v',
+	'b',  'n',  'm',  ',',  '.',  '/',  NO,   '*',	// 0x30
+	NO,   ' ',  NO,   NO,   NO,   NO,   NO,   NO,
+	NO,   NO,   NO,   NO,   NO,   NO,   NO,   '7',	// 0x40
+	'8',  '9',  '-',  '4',  '5',  '6',  '+',  '1',
+	'2',  '3',  '0',  '.',  NO,   NO,   NO,   NO,	// 0x50
+	[0xC7] = KEY_HOME,	      [0x9C] = '\n' /*KP_Enter*/,
+	[0xB5] = '/' /*KP_Div*/,      [0xC8] = KEY_UP,
+	[0xC9] = KEY_PGUP,	      [0xCB] = KEY_LF,
+	[0xCD] = KEY_RT,	      [0xCF] = KEY_END,
+	[0xD0] = KEY_DN,	      [0xD1] = KEY_PGDN,
+	[0xD2] = KEY_INS,	      [0xD3] = KEY_DEL
+};
+
+static uint8_t shiftmap[256] =
+{
+	NO,   033,  '!',  '@',  '#',  '$',  '%',  '^',	// 0x00
+	'&',  '*',  '(',  ')',  '_',  '+',  '\b', '\t',
+	'Q',  'W',  'E',  'R',  'T',  'Y',  'U',  'I',	// 0x10
+	'O',  'P',  '{',  '}',  '\n', NO,   'A',  'S',
+	'D',  'F',  'G',  'H',  'J',  'K',  'L',  ':',	// 0x20
+	'"',  '~',  NO,   '|',  'Z',  'X',  'C',  'V',
+	'B',  'N',  'M',  '<',  '>',  '?',  NO,   '*',	// 0x30
+	NO,   ' ',  NO,   NO,   NO,   NO,   NO,   NO,
+	NO,   NO,   NO,   NO,   NO,   NO,   NO,   '7',	// 0x40
+	'8',  '9',  '-',  '4',  '5',  '6',  '+',  '1',
+	'2',  '3',  '0',  '.',  NO,   NO,   NO,   NO,	// 0x50
+	[0xC7] = KEY_HOME,	      [0x9C] = '\n' /*KP_Enter*/,
+	[0xB5] = '/' /*KP_Div*/,      [0xC8] = KEY_UP,
+	[0xC9] = KEY_PGUP,	      [0xCB] = KEY_LF,
+	[0xCD] = KEY_RT,	      [0xCF] = KEY_END,
+	[0xD0] = KEY_DN,	      [0xD1] = KEY_PGDN,
+	[0xD2] = KEY_INS,	      [0xD3] = KEY_DEL
+};
+
+#define C(x) (x - '@')
+
+static uint8_t ctlmap[256] =
+{
+	NO,      NO,      NO,      NO,      NO,      NO,      NO,      NO,
+	NO,      NO,      NO,      NO,      NO,      NO,      NO,      NO,
+	C('Q'),  C('W'),  C('E'),  C('R'),  C('T'),  C('Y'),  C('U'),  C('I'),
+	C('O'),  C('P'),  NO,      NO,      '\r',    NO,      C('A'),  C('S'),
+	C('D'),  C('F'),  C('G'),  C('H'),  C('J'),  C('K'),  C('L'),  NO,
+	NO,      NO,      NO,      C('\\'), C('Z'),  C('X'),  C('C'),  C('V'),
+	C('B'),  C('N'),  C('M'),  NO,      NO,      C('/'),  NO,      NO,
+	[0x97] = KEY_HOME,
+	[0xB5] = C('/'),		[0xC8] = KEY_UP,
+	[0xC9] = KEY_PGUP,		[0xCB] = KEY_LF,
+	[0xCD] = KEY_RT,		[0xCF] = KEY_END,
+	[0xD0] = KEY_DN,		[0xD1] = KEY_PGDN,
+	[0xD2] = KEY_INS,		[0xD3] = KEY_DEL
+};
+
+static uint8_t *charcode[4] = {
+	normalmap,
+	shiftmap,
+	ctlmap,
+	ctlmap
+};
+
+/*
+ * Get data from the keyboard.  If we finish a character, return it.  Else 0.
+ * Return -1 if no data.
+ */
+static int
+kbd_proc_data(void)
+{
+	int c;
+	uint8_t stat, data;
+	static uint32_t shift;
+
+	stat = inb(KBSTATP);
+	if ((stat & KBS_DIB) == 0)
+		return -1;
+	// Ignore data from mouse.
+	if (stat & KBS_TERR)
+		return -1;
+
+	data = inb(KBDATAP);
+
+	if (data == 0xE0) {
+		// E0 escape character
+		shift |= E0ESC;
+		return 0;
+	} else if (data & 0x80) {
+		// Key released
+		data = (shift & E0ESC ? data : data & 0x7F);
+		shift &= ~(shiftcode[data] | E0ESC);
+		return 0;
+	} else if (shift & E0ESC) {
+		// Last character was an E0 escape; or with 0x80
+		data |= 0x80;
+		shift &= ~E0ESC;
+	}
+
+	shift |= shiftcode[data];
+	shift ^= togglecode[data];
+
+	c = charcode[shift & (CTL | SHIFT)][data];
+	if (shift & CAPSLOCK) {
+		if ('a' <= c && c <= 'z')
+			c += 'A' - 'a';
+		else if ('A' <= c && c <= 'Z')
+			c += 'a' - 'A';
+	}
+
+	// Process special keys
+	// Ctrl-Alt-Del: reboot
+	if (!(~shift & (CTL | ALT)) && c == KEY_DEL) {
+		cprintf("Rebooting!\n");
+		outb(0x92, 0x3); // courtesy of Chris Frost
+	}
+
+	return c;
+}
+
+void
+kbd_intr(void)
+{
+	cons_intr(kbd_proc_data);
+}
+
+static void
+kbd_init(void)
+{
+}
+
+
+
+/***** General device-independent console code *****/
+// Here we manage the console input buffer,
+// where we stash characters received from the keyboard or serial port
+// whenever the corresponding interrupt occurs.
+
+#define CONSBUFSIZE 512
+
+static struct {
+	uint8_t buf[CONSBUFSIZE];
+	uint32_t rpos;
+	uint32_t wpos;
+} cons;
+
+// called by device interrupt routines to feed input characters
+// into the circular console input buffer.
+static void
+cons_intr(int (*proc)(void))
+{
+	int c;
+
+	while ((c = (*proc)()) != -1) {
+		if (c == 0)
+			continue;
+		cons.buf[cons.wpos++] = c;
+		if (cons.wpos == CONSBUFSIZE)
+			cons.wpos = 0;
+	}
+}
+
+// return the next input character from the console, or 0 if none waiting
+int
+cons_getc(void)
+{
+	int c;
+
+	// poll for any pending input characters,
+	// so that this function works even when interrupts are disabled
+	// (e.g., when called from the kernel monitor).
+	serial_intr();
+	kbd_intr();
+
+	// grab the next character from the input buffer.
+	if (cons.rpos != cons.wpos) {
+		c = cons.buf[cons.rpos++];
+		if (cons.rpos == CONSBUFSIZE)
+			cons.rpos = 0;
+		return c;
+	}
+	return 0;
+}
+
+// output a character to the console
+static void
+cons_putc(int c)
+{
+	serial_putc(c);
+	lpt_putc(c);
+	cga_putc(c);
+}
+
+// initialize the console devices
+void
+cons_init(void)
+{
+	cga_init();
+	kbd_init();
+	serial_init();
+
+	if (!serial_exists)
+		cprintf("Serial port does not exist!\n");
+}
+
+
+// `High'-level console I/O.  Used by readline and cprintf.
+
+void
+cputchar(int c)
+{
+	cons_putc(c);
+}
+
+int
+getchar(void)
+{
+	int c;
+
+	while ((c = cons_getc()) == 0)
+		/* do nothing */;
+	return c;
+}
+
+int
+iscons(int fdnum)
+{
+	// used by readline
+	return 1;
+}
diff --git a/kern/console.h b/kern/console.h
new file mode 100644
index 0000000..3668626
--- /dev/null
+++ b/kern/console.h
@@ -0,0 +1,26 @@
+/* See COPYRIGHT for copyright information. */
+
+#ifndef _CONSOLE_H_
+#define _CONSOLE_H_
+#ifndef JOS_KERNEL
+# error "This is a JOS kernel header; user programs should not #include it"
+#endif
+
+#include <inc/types.h>
+
+#define MONO_BASE	0x3B4
+#define MONO_BUF	0xB0000
+#define CGA_BASE	0x3D4
+#define CGA_BUF		0xB8000
+
+#define CRT_ROWS	25
+#define CRT_COLS	80
+#define CRT_SIZE	(CRT_ROWS * CRT_COLS)
+
+void cons_init(void);
+int cons_getc(void);
+
+void kbd_intr(void); // irq 1
+void serial_intr(void); // irq 4
+
+#endif /* _CONSOLE_H_ */
diff --git a/kern/entry.S b/kern/entry.S
new file mode 100644
index 0000000..9550bbb
--- /dev/null
+++ b/kern/entry.S
@@ -0,0 +1,96 @@
+/* See COPYRIGHT for copyright information. */
+
+#include <inc/mmu.h>
+#include <inc/memlayout.h>
+
+# Shift Right Logical 
+#define SRL(val, shamt)		(((val) >> (shamt)) & ~(-1 << (32 - (shamt))))
+
+
+###################################################################
+# The kernel (this code) is linked at address ~(KERNBASE + 1 Meg), 
+# but the bootloader loads it at address ~1 Meg.
+#	
+# RELOC(x) maps a symbol x from its link address to its actual
+# location in physical memory (its load address).	 
+###################################################################
+
+#define	RELOC(x) ((x) - KERNBASE)
+
+#define MULTIBOOT_HEADER_MAGIC (0x1BADB002)
+#define MULTIBOOT_HEADER_FLAGS (0)
+#define CHECKSUM (-(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS))
+
+###################################################################
+# entry point
+###################################################################
+
+.text
+
+# The Multiboot header
+.align 4
+.long MULTIBOOT_HEADER_MAGIC
+.long MULTIBOOT_HEADER_FLAGS
+.long CHECKSUM
+
+# '_start' specifies the ELF entry point.  Since we haven't set up
+# virtual memory when the bootloader enters this code, we need the
+# bootloader to jump to the *physical* address of the entry point.
+.globl		_start
+_start = RELOC(entry)
+
+.globl entry
+entry:
+	movw	$0x1234,0x472			# warm boot
+
+	# We haven't set up virtual memory yet, so we're running from
+	# the physical address the boot loader loaded the kernel at: 1MB
+	# (plus a few bytes).  However, the C code is linked to run at
+	# KERNBASE+1MB.  Hence, we set up a trivial page directory that
+	# translates virtual addresses [KERNBASE, KERNBASE+4MB) to
+	# physical addresses [0, 4MB).  This 4MB region will be
+	# sufficient until we set up our real page table in mem_init
+	# in lab 2.
+
+	# Load the physical address of entry_pgdir into cr3.  entry_pgdir
+	# is defined in entrypgdir.c.
+	movl	$(RELOC(entry_pgdir)), %eax
+	movl	%eax, %cr3
+	# Turn on paging.
+	movl	%cr0, %eax
+	orl	$(CR0_PE|CR0_PG|CR0_WP), %eax
+	movl	%eax, %cr0
+
+	# Now paging is enabled, but we're still running at a low EIP
+	# (why is this okay?).  Jump up above KERNBASE before entering
+	# C code.
+	mov	$relocated, %eax
+	jmp	*%eax
+relocated:
+
+	# Clear the frame pointer register (EBP)
+	# so that once we get into debugging C code,
+	# stack backtraces will be terminated properly.
+	movl	$0x0,%ebp			# nuke frame pointer
+
+	# Set the stack pointer
+	movl	$(bootstacktop),%esp
+
+	# now to C code
+	call	i386_init
+
+	# Should never get here, but in case we do, just spin.
+spin:	jmp	spin
+
+
+.data
+###################################################################
+# boot stack
+###################################################################
+	.p2align	PGSHIFT		# force page alignment
+	.globl		bootstack
+bootstack:
+	.space		KSTKSIZE
+	.globl		bootstacktop   
+bootstacktop:
+
diff --git a/kern/entrypgdir.c b/kern/entrypgdir.c
new file mode 100644
index 0000000..4f324d1
--- /dev/null
+++ b/kern/entrypgdir.c
@@ -0,0 +1,1059 @@
+#include <inc/mmu.h>
+#include <inc/memlayout.h>
+
+pte_t entry_pgtable[NPTENTRIES];
+
+// The entry.S page directory maps the first 4MB of physical memory
+// starting at virtual address KERNBASE (that is, it maps virtual
+// addresses [KERNBASE, KERNBASE+4MB) to physical addresses [0, 4MB)).
+// We choose 4MB because that's how much we can map with one page
+// table and it's enough to get us through early boot.  We also map
+// virtual addresses [0, 4MB) to physical addresses [0, 4MB); this
+// region is critical for a few instructions in entry.S and then we
+// never use it again.
+//
+// Page directories (and page tables), must start on a page boundary,
+// hence the "__aligned__" attribute.  Also, because of restrictions
+// related to linking and static initializers, we use "x + PTE_P"
+// here, rather than the more standard "x | PTE_P".  Everywhere else
+// you should use "|" to combine flags.
+__attribute__((__aligned__(PGSIZE)))
+pde_t entry_pgdir[NPDENTRIES] = {
+	// Map VA's [0, 4MB) to PA's [0, 4MB)
+	[0]
+		= ((uintptr_t)entry_pgtable - KERNBASE) + PTE_P,
+	// Map VA's [KERNBASE, KERNBASE+4MB) to PA's [0, 4MB)
+	[KERNBASE>>PDXSHIFT]
+		= ((uintptr_t)entry_pgtable - KERNBASE) + PTE_P + PTE_W
+};
+
+// Entry 0 of the page table maps to physical page 0, entry 1 to
+// physical page 1, etc.
+__attribute__((__aligned__(PGSIZE)))
+pte_t entry_pgtable[NPTENTRIES] = {
+	0x000000 | PTE_P | PTE_W,
+	0x001000 | PTE_P | PTE_W,
+	0x002000 | PTE_P | PTE_W,
+	0x003000 | PTE_P | PTE_W,
+	0x004000 | PTE_P | PTE_W,
+	0x005000 | PTE_P | PTE_W,
+	0x006000 | PTE_P | PTE_W,
+	0x007000 | PTE_P | PTE_W,
+	0x008000 | PTE_P | PTE_W,
+	0x009000 | PTE_P | PTE_W,
+	0x00a000 | PTE_P | PTE_W,
+	0x00b000 | PTE_P | PTE_W,
+	0x00c000 | PTE_P | PTE_W,
+	0x00d000 | PTE_P | PTE_W,
+	0x00e000 | PTE_P | PTE_W,
+	0x00f000 | PTE_P | PTE_W,
+	0x010000 | PTE_P | PTE_W,
+	0x011000 | PTE_P | PTE_W,
+	0x012000 | PTE_P | PTE_W,
+	0x013000 | PTE_P | PTE_W,
+	0x014000 | PTE_P | PTE_W,
+	0x015000 | PTE_P | PTE_W,
+	0x016000 | PTE_P | PTE_W,
+	0x017000 | PTE_P | PTE_W,
+	0x018000 | PTE_P | PTE_W,
+	0x019000 | PTE_P | PTE_W,
+	0x01a000 | PTE_P | PTE_W,
+	0x01b000 | PTE_P | PTE_W,
+	0x01c000 | PTE_P | PTE_W,
+	0x01d000 | PTE_P | PTE_W,
+	0x01e000 | PTE_P | PTE_W,
+	0x01f000 | PTE_P | PTE_W,
+	0x020000 | PTE_P | PTE_W,
+	0x021000 | PTE_P | PTE_W,
+	0x022000 | PTE_P | PTE_W,
+	0x023000 | PTE_P | PTE_W,
+	0x024000 | PTE_P | PTE_W,
+	0x025000 | PTE_P | PTE_W,
+	0x026000 | PTE_P | PTE_W,
+	0x027000 | PTE_P | PTE_W,
+	0x028000 | PTE_P | PTE_W,
+	0x029000 | PTE_P | PTE_W,
+	0x02a000 | PTE_P | PTE_W,
+	0x02b000 | PTE_P | PTE_W,
+	0x02c000 | PTE_P | PTE_W,
+	0x02d000 | PTE_P | PTE_W,
+	0x02e000 | PTE_P | PTE_W,
+	0x02f000 | PTE_P | PTE_W,
+	0x030000 | PTE_P | PTE_W,
+	0x031000 | PTE_P | PTE_W,
+	0x032000 | PTE_P | PTE_W,
+	0x033000 | PTE_P | PTE_W,
+	0x034000 | PTE_P | PTE_W,
+	0x035000 | PTE_P | PTE_W,
+	0x036000 | PTE_P | PTE_W,
+	0x037000 | PTE_P | PTE_W,
+	0x038000 | PTE_P | PTE_W,
+	0x039000 | PTE_P | PTE_W,
+	0x03a000 | PTE_P | PTE_W,
+	0x03b000 | PTE_P | PTE_W,
+	0x03c000 | PTE_P | PTE_W,
+	0x03d000 | PTE_P | PTE_W,
+	0x03e000 | PTE_P | PTE_W,
+	0x03f000 | PTE_P | PTE_W,
+	0x040000 | PTE_P | PTE_W,
+	0x041000 | PTE_P | PTE_W,
+	0x042000 | PTE_P | PTE_W,
+	0x043000 | PTE_P | PTE_W,
+	0x044000 | PTE_P | PTE_W,
+	0x045000 | PTE_P | PTE_W,
+	0x046000 | PTE_P | PTE_W,
+	0x047000 | PTE_P | PTE_W,
+	0x048000 | PTE_P | PTE_W,
+	0x049000 | PTE_P | PTE_W,
+	0x04a000 | PTE_P | PTE_W,
+	0x04b000 | PTE_P | PTE_W,
+	0x04c000 | PTE_P | PTE_W,
+	0x04d000 | PTE_P | PTE_W,
+	0x04e000 | PTE_P | PTE_W,
+	0x04f000 | PTE_P | PTE_W,
+	0x050000 | PTE_P | PTE_W,
+	0x051000 | PTE_P | PTE_W,
+	0x052000 | PTE_P | PTE_W,
+	0x053000 | PTE_P | PTE_W,
+	0x054000 | PTE_P | PTE_W,
+	0x055000 | PTE_P | PTE_W,
+	0x056000 | PTE_P | PTE_W,
+	0x057000 | PTE_P | PTE_W,
+	0x058000 | PTE_P | PTE_W,
+	0x059000 | PTE_P | PTE_W,
+	0x05a000 | PTE_P | PTE_W,
+	0x05b000 | PTE_P | PTE_W,
+	0x05c000 | PTE_P | PTE_W,
+	0x05d000 | PTE_P | PTE_W,
+	0x05e000 | PTE_P | PTE_W,
+	0x05f000 | PTE_P | PTE_W,
+	0x060000 | PTE_P | PTE_W,
+	0x061000 | PTE_P | PTE_W,
+	0x062000 | PTE_P | PTE_W,
+	0x063000 | PTE_P | PTE_W,
+	0x064000 | PTE_P | PTE_W,
+	0x065000 | PTE_P | PTE_W,
+	0x066000 | PTE_P | PTE_W,
+	0x067000 | PTE_P | PTE_W,
+	0x068000 | PTE_P | PTE_W,
+	0x069000 | PTE_P | PTE_W,
+	0x06a000 | PTE_P | PTE_W,
+	0x06b000 | PTE_P | PTE_W,
+	0x06c000 | PTE_P | PTE_W,
+	0x06d000 | PTE_P | PTE_W,
+	0x06e000 | PTE_P | PTE_W,
+	0x06f000 | PTE_P | PTE_W,
+	0x070000 | PTE_P | PTE_W,
+	0x071000 | PTE_P | PTE_W,
+	0x072000 | PTE_P | PTE_W,
+	0x073000 | PTE_P | PTE_W,
+	0x074000 | PTE_P | PTE_W,
+	0x075000 | PTE_P | PTE_W,
+	0x076000 | PTE_P | PTE_W,
+	0x077000 | PTE_P | PTE_W,
+	0x078000 | PTE_P | PTE_W,
+	0x079000 | PTE_P | PTE_W,
+	0x07a000 | PTE_P | PTE_W,
+	0x07b000 | PTE_P | PTE_W,
+	0x07c000 | PTE_P | PTE_W,
+	0x07d000 | PTE_P | PTE_W,
+	0x07e000 | PTE_P | PTE_W,
+	0x07f000 | PTE_P | PTE_W,
+	0x080000 | PTE_P | PTE_W,
+	0x081000 | PTE_P | PTE_W,
+	0x082000 | PTE_P | PTE_W,
+	0x083000 | PTE_P | PTE_W,
+	0x084000 | PTE_P | PTE_W,
+	0x085000 | PTE_P | PTE_W,
+	0x086000 | PTE_P | PTE_W,
+	0x087000 | PTE_P | PTE_W,
+	0x088000 | PTE_P | PTE_W,
+	0x089000 | PTE_P | PTE_W,
+	0x08a000 | PTE_P | PTE_W,
+	0x08b000 | PTE_P | PTE_W,
+	0x08c000 | PTE_P | PTE_W,
+	0x08d000 | PTE_P | PTE_W,
+	0x08e000 | PTE_P | PTE_W,
+	0x08f000 | PTE_P | PTE_W,
+	0x090000 | PTE_P | PTE_W,
+	0x091000 | PTE_P | PTE_W,
+	0x092000 | PTE_P | PTE_W,
+	0x093000 | PTE_P | PTE_W,
+	0x094000 | PTE_P | PTE_W,
+	0x095000 | PTE_P | PTE_W,
+	0x096000 | PTE_P | PTE_W,
+	0x097000 | PTE_P | PTE_W,
+	0x098000 | PTE_P | PTE_W,
+	0x099000 | PTE_P | PTE_W,
+	0x09a000 | PTE_P | PTE_W,
+	0x09b000 | PTE_P | PTE_W,
+	0x09c000 | PTE_P | PTE_W,
+	0x09d000 | PTE_P | PTE_W,
+	0x09e000 | PTE_P | PTE_W,
+	0x09f000 | PTE_P | PTE_W,
+	0x0a0000 | PTE_P | PTE_W,
+	0x0a1000 | PTE_P | PTE_W,
+	0x0a2000 | PTE_P | PTE_W,
+	0x0a3000 | PTE_P | PTE_W,
+	0x0a4000 | PTE_P | PTE_W,
+	0x0a5000 | PTE_P | PTE_W,
+	0x0a6000 | PTE_P | PTE_W,
+	0x0a7000 | PTE_P | PTE_W,
+	0x0a8000 | PTE_P | PTE_W,
+	0x0a9000 | PTE_P | PTE_W,
+	0x0aa000 | PTE_P | PTE_W,
+	0x0ab000 | PTE_P | PTE_W,
+	0x0ac000 | PTE_P | PTE_W,
+	0x0ad000 | PTE_P | PTE_W,
+	0x0ae000 | PTE_P | PTE_W,
+	0x0af000 | PTE_P | PTE_W,
+	0x0b0000 | PTE_P | PTE_W,
+	0x0b1000 | PTE_P | PTE_W,
+	0x0b2000 | PTE_P | PTE_W,
+	0x0b3000 | PTE_P | PTE_W,
+	0x0b4000 | PTE_P | PTE_W,
+	0x0b5000 | PTE_P | PTE_W,
+	0x0b6000 | PTE_P | PTE_W,
+	0x0b7000 | PTE_P | PTE_W,
+	0x0b8000 | PTE_P | PTE_W,
+	0x0b9000 | PTE_P | PTE_W,
+	0x0ba000 | PTE_P | PTE_W,
+	0x0bb000 | PTE_P | PTE_W,
+	0x0bc000 | PTE_P | PTE_W,
+	0x0bd000 | PTE_P | PTE_W,
+	0x0be000 | PTE_P | PTE_W,
+	0x0bf000 | PTE_P | PTE_W,
+	0x0c0000 | PTE_P | PTE_W,
+	0x0c1000 | PTE_P | PTE_W,
+	0x0c2000 | PTE_P | PTE_W,
+	0x0c3000 | PTE_P | PTE_W,
+	0x0c4000 | PTE_P | PTE_W,
+	0x0c5000 | PTE_P | PTE_W,
+	0x0c6000 | PTE_P | PTE_W,
+	0x0c7000 | PTE_P | PTE_W,
+	0x0c8000 | PTE_P | PTE_W,
+	0x0c9000 | PTE_P | PTE_W,
+	0x0ca000 | PTE_P | PTE_W,
+	0x0cb000 | PTE_P | PTE_W,
+	0x0cc000 | PTE_P | PTE_W,
+	0x0cd000 | PTE_P | PTE_W,
+	0x0ce000 | PTE_P | PTE_W,
+	0x0cf000 | PTE_P | PTE_W,
+	0x0d0000 | PTE_P | PTE_W,
+	0x0d1000 | PTE_P | PTE_W,
+	0x0d2000 | PTE_P | PTE_W,
+	0x0d3000 | PTE_P | PTE_W,
+	0x0d4000 | PTE_P | PTE_W,
+	0x0d5000 | PTE_P | PTE_W,
+	0x0d6000 | PTE_P | PTE_W,
+	0x0d7000 | PTE_P | PTE_W,
+	0x0d8000 | PTE_P | PTE_W,
+	0x0d9000 | PTE_P | PTE_W,
+	0x0da000 | PTE_P | PTE_W,
+	0x0db000 | PTE_P | PTE_W,
+	0x0dc000 | PTE_P | PTE_W,
+	0x0dd000 | PTE_P | PTE_W,
+	0x0de000 | PTE_P | PTE_W,
+	0x0df000 | PTE_P | PTE_W,
+	0x0e0000 | PTE_P | PTE_W,
+	0x0e1000 | PTE_P | PTE_W,
+	0x0e2000 | PTE_P | PTE_W,
+	0x0e3000 | PTE_P | PTE_W,
+	0x0e4000 | PTE_P | PTE_W,
+	0x0e5000 | PTE_P | PTE_W,
+	0x0e6000 | PTE_P | PTE_W,
+	0x0e7000 | PTE_P | PTE_W,
+	0x0e8000 | PTE_P | PTE_W,
+	0x0e9000 | PTE_P | PTE_W,
+	0x0ea000 | PTE_P | PTE_W,
+	0x0eb000 | PTE_P | PTE_W,
+	0x0ec000 | PTE_P | PTE_W,
+	0x0ed000 | PTE_P | PTE_W,
+	0x0ee000 | PTE_P | PTE_W,
+	0x0ef000 | PTE_P | PTE_W,
+	0x0f0000 | PTE_P | PTE_W,
+	0x0f1000 | PTE_P | PTE_W,
+	0x0f2000 | PTE_P | PTE_W,
+	0x0f3000 | PTE_P | PTE_W,
+	0x0f4000 | PTE_P | PTE_W,
+	0x0f5000 | PTE_P | PTE_W,
+	0x0f6000 | PTE_P | PTE_W,
+	0x0f7000 | PTE_P | PTE_W,
+	0x0f8000 | PTE_P | PTE_W,
+	0x0f9000 | PTE_P | PTE_W,
+	0x0fa000 | PTE_P | PTE_W,
+	0x0fb000 | PTE_P | PTE_W,
+	0x0fc000 | PTE_P | PTE_W,
+	0x0fd000 | PTE_P | PTE_W,
+	0x0fe000 | PTE_P | PTE_W,
+	0x0ff000 | PTE_P | PTE_W,
+	0x100000 | PTE_P | PTE_W,
+	0x101000 | PTE_P | PTE_W,
+	0x102000 | PTE_P | PTE_W,
+	0x103000 | PTE_P | PTE_W,
+	0x104000 | PTE_P | PTE_W,
+	0x105000 | PTE_P | PTE_W,
+	0x106000 | PTE_P | PTE_W,
+	0x107000 | PTE_P | PTE_W,
+	0x108000 | PTE_P | PTE_W,
+	0x109000 | PTE_P | PTE_W,
+	0x10a000 | PTE_P | PTE_W,
+	0x10b000 | PTE_P | PTE_W,
+	0x10c000 | PTE_P | PTE_W,
+	0x10d000 | PTE_P | PTE_W,
+	0x10e000 | PTE_P | PTE_W,
+	0x10f000 | PTE_P | PTE_W,
+	0x110000 | PTE_P | PTE_W,
+	0x111000 | PTE_P | PTE_W,
+	0x112000 | PTE_P | PTE_W,
+	0x113000 | PTE_P | PTE_W,
+	0x114000 | PTE_P | PTE_W,
+	0x115000 | PTE_P | PTE_W,
+	0x116000 | PTE_P | PTE_W,
+	0x117000 | PTE_P | PTE_W,
+	0x118000 | PTE_P | PTE_W,
+	0x119000 | PTE_P | PTE_W,
+	0x11a000 | PTE_P | PTE_W,
+	0x11b000 | PTE_P | PTE_W,
+	0x11c000 | PTE_P | PTE_W,
+	0x11d000 | PTE_P | PTE_W,
+	0x11e000 | PTE_P | PTE_W,
+	0x11f000 | PTE_P | PTE_W,
+	0x120000 | PTE_P | PTE_W,
+	0x121000 | PTE_P | PTE_W,
+	0x122000 | PTE_P | PTE_W,
+	0x123000 | PTE_P | PTE_W,
+	0x124000 | PTE_P | PTE_W,
+	0x125000 | PTE_P | PTE_W,
+	0x126000 | PTE_P | PTE_W,
+	0x127000 | PTE_P | PTE_W,
+	0x128000 | PTE_P | PTE_W,
+	0x129000 | PTE_P | PTE_W,
+	0x12a000 | PTE_P | PTE_W,
+	0x12b000 | PTE_P | PTE_W,
+	0x12c000 | PTE_P | PTE_W,
+	0x12d000 | PTE_P | PTE_W,
+	0x12e000 | PTE_P | PTE_W,
+	0x12f000 | PTE_P | PTE_W,
+	0x130000 | PTE_P | PTE_W,
+	0x131000 | PTE_P | PTE_W,
+	0x132000 | PTE_P | PTE_W,
+	0x133000 | PTE_P | PTE_W,
+	0x134000 | PTE_P | PTE_W,
+	0x135000 | PTE_P | PTE_W,
+	0x136000 | PTE_P | PTE_W,
+	0x137000 | PTE_P | PTE_W,
+	0x138000 | PTE_P | PTE_W,
+	0x139000 | PTE_P | PTE_W,
+	0x13a000 | PTE_P | PTE_W,
+	0x13b000 | PTE_P | PTE_W,
+	0x13c000 | PTE_P | PTE_W,
+	0x13d000 | PTE_P | PTE_W,
+	0x13e000 | PTE_P | PTE_W,
+	0x13f000 | PTE_P | PTE_W,
+	0x140000 | PTE_P | PTE_W,
+	0x141000 | PTE_P | PTE_W,
+	0x142000 | PTE_P | PTE_W,
+	0x143000 | PTE_P | PTE_W,
+	0x144000 | PTE_P | PTE_W,
+	0x145000 | PTE_P | PTE_W,
+	0x146000 | PTE_P | PTE_W,
+	0x147000 | PTE_P | PTE_W,
+	0x148000 | PTE_P | PTE_W,
+	0x149000 | PTE_P | PTE_W,
+	0x14a000 | PTE_P | PTE_W,
+	0x14b000 | PTE_P | PTE_W,
+	0x14c000 | PTE_P | PTE_W,
+	0x14d000 | PTE_P | PTE_W,
+	0x14e000 | PTE_P | PTE_W,
+	0x14f000 | PTE_P | PTE_W,
+	0x150000 | PTE_P | PTE_W,
+	0x151000 | PTE_P | PTE_W,
+	0x152000 | PTE_P | PTE_W,
+	0x153000 | PTE_P | PTE_W,
+	0x154000 | PTE_P | PTE_W,
+	0x155000 | PTE_P | PTE_W,
+	0x156000 | PTE_P | PTE_W,
+	0x157000 | PTE_P | PTE_W,
+	0x158000 | PTE_P | PTE_W,
+	0x159000 | PTE_P | PTE_W,
+	0x15a000 | PTE_P | PTE_W,
+	0x15b000 | PTE_P | PTE_W,
+	0x15c000 | PTE_P | PTE_W,
+	0x15d000 | PTE_P | PTE_W,
+	0x15e000 | PTE_P | PTE_W,
+	0x15f000 | PTE_P | PTE_W,
+	0x160000 | PTE_P | PTE_W,
+	0x161000 | PTE_P | PTE_W,
+	0x162000 | PTE_P | PTE_W,
+	0x163000 | PTE_P | PTE_W,
+	0x164000 | PTE_P | PTE_W,
+	0x165000 | PTE_P | PTE_W,
+	0x166000 | PTE_P | PTE_W,
+	0x167000 | PTE_P | PTE_W,
+	0x168000 | PTE_P | PTE_W,
+	0x169000 | PTE_P | PTE_W,
+	0x16a000 | PTE_P | PTE_W,
+	0x16b000 | PTE_P | PTE_W,
+	0x16c000 | PTE_P | PTE_W,
+	0x16d000 | PTE_P | PTE_W,
+	0x16e000 | PTE_P | PTE_W,
+	0x16f000 | PTE_P | PTE_W,
+	0x170000 | PTE_P | PTE_W,
+	0x171000 | PTE_P | PTE_W,
+	0x172000 | PTE_P | PTE_W,
+	0x173000 | PTE_P | PTE_W,
+	0x174000 | PTE_P | PTE_W,
+	0x175000 | PTE_P | PTE_W,
+	0x176000 | PTE_P | PTE_W,
+	0x177000 | PTE_P | PTE_W,
+	0x178000 | PTE_P | PTE_W,
+	0x179000 | PTE_P | PTE_W,
+	0x17a000 | PTE_P | PTE_W,
+	0x17b000 | PTE_P | PTE_W,
+	0x17c000 | PTE_P | PTE_W,
+	0x17d000 | PTE_P | PTE_W,
+	0x17e000 | PTE_P | PTE_W,
+	0x17f000 | PTE_P | PTE_W,
+	0x180000 | PTE_P | PTE_W,
+	0x181000 | PTE_P | PTE_W,
+	0x182000 | PTE_P | PTE_W,
+	0x183000 | PTE_P | PTE_W,
+	0x184000 | PTE_P | PTE_W,
+	0x185000 | PTE_P | PTE_W,
+	0x186000 | PTE_P | PTE_W,
+	0x187000 | PTE_P | PTE_W,
+	0x188000 | PTE_P | PTE_W,
+	0x189000 | PTE_P | PTE_W,
+	0x18a000 | PTE_P | PTE_W,
+	0x18b000 | PTE_P | PTE_W,
+	0x18c000 | PTE_P | PTE_W,
+	0x18d000 | PTE_P | PTE_W,
+	0x18e000 | PTE_P | PTE_W,
+	0x18f000 | PTE_P | PTE_W,
+	0x190000 | PTE_P | PTE_W,
+	0x191000 | PTE_P | PTE_W,
+	0x192000 | PTE_P | PTE_W,
+	0x193000 | PTE_P | PTE_W,
+	0x194000 | PTE_P | PTE_W,
+	0x195000 | PTE_P | PTE_W,
+	0x196000 | PTE_P | PTE_W,
+	0x197000 | PTE_P | PTE_W,
+	0x198000 | PTE_P | PTE_W,
+	0x199000 | PTE_P | PTE_W,
+	0x19a000 | PTE_P | PTE_W,
+	0x19b000 | PTE_P | PTE_W,
+	0x19c000 | PTE_P | PTE_W,
+	0x19d000 | PTE_P | PTE_W,
+	0x19e000 | PTE_P | PTE_W,
+	0x19f000 | PTE_P | PTE_W,
+	0x1a0000 | PTE_P | PTE_W,
+	0x1a1000 | PTE_P | PTE_W,
+	0x1a2000 | PTE_P | PTE_W,
+	0x1a3000 | PTE_P | PTE_W,
+	0x1a4000 | PTE_P | PTE_W,
+	0x1a5000 | PTE_P | PTE_W,
+	0x1a6000 | PTE_P | PTE_W,
+	0x1a7000 | PTE_P | PTE_W,
+	0x1a8000 | PTE_P | PTE_W,
+	0x1a9000 | PTE_P | PTE_W,
+	0x1aa000 | PTE_P | PTE_W,
+	0x1ab000 | PTE_P | PTE_W,
+	0x1ac000 | PTE_P | PTE_W,
+	0x1ad000 | PTE_P | PTE_W,
+	0x1ae000 | PTE_P | PTE_W,
+	0x1af000 | PTE_P | PTE_W,
+	0x1b0000 | PTE_P | PTE_W,
+	0x1b1000 | PTE_P | PTE_W,
+	0x1b2000 | PTE_P | PTE_W,
+	0x1b3000 | PTE_P | PTE_W,
+	0x1b4000 | PTE_P | PTE_W,
+	0x1b5000 | PTE_P | PTE_W,
+	0x1b6000 | PTE_P | PTE_W,
+	0x1b7000 | PTE_P | PTE_W,
+	0x1b8000 | PTE_P | PTE_W,
+	0x1b9000 | PTE_P | PTE_W,
+	0x1ba000 | PTE_P | PTE_W,
+	0x1bb000 | PTE_P | PTE_W,
+	0x1bc000 | PTE_P | PTE_W,
+	0x1bd000 | PTE_P | PTE_W,
+	0x1be000 | PTE_P | PTE_W,
+	0x1bf000 | PTE_P | PTE_W,
+	0x1c0000 | PTE_P | PTE_W,
+	0x1c1000 | PTE_P | PTE_W,
+	0x1c2000 | PTE_P | PTE_W,
+	0x1c3000 | PTE_P | PTE_W,
+	0x1c4000 | PTE_P | PTE_W,
+	0x1c5000 | PTE_P | PTE_W,
+	0x1c6000 | PTE_P | PTE_W,
+	0x1c7000 | PTE_P | PTE_W,
+	0x1c8000 | PTE_P | PTE_W,
+	0x1c9000 | PTE_P | PTE_W,
+	0x1ca000 | PTE_P | PTE_W,
+	0x1cb000 | PTE_P | PTE_W,
+	0x1cc000 | PTE_P | PTE_W,
+	0x1cd000 | PTE_P | PTE_W,
+	0x1ce000 | PTE_P | PTE_W,
+	0x1cf000 | PTE_P | PTE_W,
+	0x1d0000 | PTE_P | PTE_W,
+	0x1d1000 | PTE_P | PTE_W,
+	0x1d2000 | PTE_P | PTE_W,
+	0x1d3000 | PTE_P | PTE_W,
+	0x1d4000 | PTE_P | PTE_W,
+	0x1d5000 | PTE_P | PTE_W,
+	0x1d6000 | PTE_P | PTE_W,
+	0x1d7000 | PTE_P | PTE_W,
+	0x1d8000 | PTE_P | PTE_W,
+	0x1d9000 | PTE_P | PTE_W,
+	0x1da000 | PTE_P | PTE_W,
+	0x1db000 | PTE_P | PTE_W,
+	0x1dc000 | PTE_P | PTE_W,
+	0x1dd000 | PTE_P | PTE_W,
+	0x1de000 | PTE_P | PTE_W,
+	0x1df000 | PTE_P | PTE_W,
+	0x1e0000 | PTE_P | PTE_W,
+	0x1e1000 | PTE_P | PTE_W,
+	0x1e2000 | PTE_P | PTE_W,
+	0x1e3000 | PTE_P | PTE_W,
+	0x1e4000 | PTE_P | PTE_W,
+	0x1e5000 | PTE_P | PTE_W,
+	0x1e6000 | PTE_P | PTE_W,
+	0x1e7000 | PTE_P | PTE_W,
+	0x1e8000 | PTE_P | PTE_W,
+	0x1e9000 | PTE_P | PTE_W,
+	0x1ea000 | PTE_P | PTE_W,
+	0x1eb000 | PTE_P | PTE_W,
+	0x1ec000 | PTE_P | PTE_W,
+	0x1ed000 | PTE_P | PTE_W,
+	0x1ee000 | PTE_P | PTE_W,
+	0x1ef000 | PTE_P | PTE_W,
+	0x1f0000 | PTE_P | PTE_W,
+	0x1f1000 | PTE_P | PTE_W,
+	0x1f2000 | PTE_P | PTE_W,
+	0x1f3000 | PTE_P | PTE_W,
+	0x1f4000 | PTE_P | PTE_W,
+	0x1f5000 | PTE_P | PTE_W,
+	0x1f6000 | PTE_P | PTE_W,
+	0x1f7000 | PTE_P | PTE_W,
+	0x1f8000 | PTE_P | PTE_W,
+	0x1f9000 | PTE_P | PTE_W,
+	0x1fa000 | PTE_P | PTE_W,
+	0x1fb000 | PTE_P | PTE_W,
+	0x1fc000 | PTE_P | PTE_W,
+	0x1fd000 | PTE_P | PTE_W,
+	0x1fe000 | PTE_P | PTE_W,
+	0x1ff000 | PTE_P | PTE_W,
+	0x200000 | PTE_P | PTE_W,
+	0x201000 | PTE_P | PTE_W,
+	0x202000 | PTE_P | PTE_W,
+	0x203000 | PTE_P | PTE_W,
+	0x204000 | PTE_P | PTE_W,
+	0x205000 | PTE_P | PTE_W,
+	0x206000 | PTE_P | PTE_W,
+	0x207000 | PTE_P | PTE_W,
+	0x208000 | PTE_P | PTE_W,
+	0x209000 | PTE_P | PTE_W,
+	0x20a000 | PTE_P | PTE_W,
+	0x20b000 | PTE_P | PTE_W,
+	0x20c000 | PTE_P | PTE_W,
+	0x20d000 | PTE_P | PTE_W,
+	0x20e000 | PTE_P | PTE_W,
+	0x20f000 | PTE_P | PTE_W,
+	0x210000 | PTE_P | PTE_W,
+	0x211000 | PTE_P | PTE_W,
+	0x212000 | PTE_P | PTE_W,
+	0x213000 | PTE_P | PTE_W,
+	0x214000 | PTE_P | PTE_W,
+	0x215000 | PTE_P | PTE_W,
+	0x216000 | PTE_P | PTE_W,
+	0x217000 | PTE_P | PTE_W,
+	0x218000 | PTE_P | PTE_W,
+	0x219000 | PTE_P | PTE_W,
+	0x21a000 | PTE_P | PTE_W,
+	0x21b000 | PTE_P | PTE_W,
+	0x21c000 | PTE_P | PTE_W,
+	0x21d000 | PTE_P | PTE_W,
+	0x21e000 | PTE_P | PTE_W,
+	0x21f000 | PTE_P | PTE_W,
+	0x220000 | PTE_P | PTE_W,
+	0x221000 | PTE_P | PTE_W,
+	0x222000 | PTE_P | PTE_W,
+	0x223000 | PTE_P | PTE_W,
+	0x224000 | PTE_P | PTE_W,
+	0x225000 | PTE_P | PTE_W,
+	0x226000 | PTE_P | PTE_W,
+	0x227000 | PTE_P | PTE_W,
+	0x228000 | PTE_P | PTE_W,
+	0x229000 | PTE_P | PTE_W,
+	0x22a000 | PTE_P | PTE_W,
+	0x22b000 | PTE_P | PTE_W,
+	0x22c000 | PTE_P | PTE_W,
+	0x22d000 | PTE_P | PTE_W,
+	0x22e000 | PTE_P | PTE_W,
+	0x22f000 | PTE_P | PTE_W,
+	0x230000 | PTE_P | PTE_W,
+	0x231000 | PTE_P | PTE_W,
+	0x232000 | PTE_P | PTE_W,
+	0x233000 | PTE_P | PTE_W,
+	0x234000 | PTE_P | PTE_W,
+	0x235000 | PTE_P | PTE_W,
+	0x236000 | PTE_P | PTE_W,
+	0x237000 | PTE_P | PTE_W,
+	0x238000 | PTE_P | PTE_W,
+	0x239000 | PTE_P | PTE_W,
+	0x23a000 | PTE_P | PTE_W,
+	0x23b000 | PTE_P | PTE_W,
+	0x23c000 | PTE_P | PTE_W,
+	0x23d000 | PTE_P | PTE_W,
+	0x23e000 | PTE_P | PTE_W,
+	0x23f000 | PTE_P | PTE_W,
+	0x240000 | PTE_P | PTE_W,
+	0x241000 | PTE_P | PTE_W,
+	0x242000 | PTE_P | PTE_W,
+	0x243000 | PTE_P | PTE_W,
+	0x244000 | PTE_P | PTE_W,
+	0x245000 | PTE_P | PTE_W,
+	0x246000 | PTE_P | PTE_W,
+	0x247000 | PTE_P | PTE_W,
+	0x248000 | PTE_P | PTE_W,
+	0x249000 | PTE_P | PTE_W,
+	0x24a000 | PTE_P | PTE_W,
+	0x24b000 | PTE_P | PTE_W,
+	0x24c000 | PTE_P | PTE_W,
+	0x24d000 | PTE_P | PTE_W,
+	0x24e000 | PTE_P | PTE_W,
+	0x24f000 | PTE_P | PTE_W,
+	0x250000 | PTE_P | PTE_W,
+	0x251000 | PTE_P | PTE_W,
+	0x252000 | PTE_P | PTE_W,
+	0x253000 | PTE_P | PTE_W,
+	0x254000 | PTE_P | PTE_W,
+	0x255000 | PTE_P | PTE_W,
+	0x256000 | PTE_P | PTE_W,
+	0x257000 | PTE_P | PTE_W,
+	0x258000 | PTE_P | PTE_W,
+	0x259000 | PTE_P | PTE_W,
+	0x25a000 | PTE_P | PTE_W,
+	0x25b000 | PTE_P | PTE_W,
+	0x25c000 | PTE_P | PTE_W,
+	0x25d000 | PTE_P | PTE_W,
+	0x25e000 | PTE_P | PTE_W,
+	0x25f000 | PTE_P | PTE_W,
+	0x260000 | PTE_P | PTE_W,
+	0x261000 | PTE_P | PTE_W,
+	0x262000 | PTE_P | PTE_W,
+	0x263000 | PTE_P | PTE_W,
+	0x264000 | PTE_P | PTE_W,
+	0x265000 | PTE_P | PTE_W,
+	0x266000 | PTE_P | PTE_W,
+	0x267000 | PTE_P | PTE_W,
+	0x268000 | PTE_P | PTE_W,
+	0x269000 | PTE_P | PTE_W,
+	0x26a000 | PTE_P | PTE_W,
+	0x26b000 | PTE_P | PTE_W,
+	0x26c000 | PTE_P | PTE_W,
+	0x26d000 | PTE_P | PTE_W,
+	0x26e000 | PTE_P | PTE_W,
+	0x26f000 | PTE_P | PTE_W,
+	0x270000 | PTE_P | PTE_W,
+	0x271000 | PTE_P | PTE_W,
+	0x272000 | PTE_P | PTE_W,
+	0x273000 | PTE_P | PTE_W,
+	0x274000 | PTE_P | PTE_W,
+	0x275000 | PTE_P | PTE_W,
+	0x276000 | PTE_P | PTE_W,
+	0x277000 | PTE_P | PTE_W,
+	0x278000 | PTE_P | PTE_W,
+	0x279000 | PTE_P | PTE_W,
+	0x27a000 | PTE_P | PTE_W,
+	0x27b000 | PTE_P | PTE_W,
+	0x27c000 | PTE_P | PTE_W,
+	0x27d000 | PTE_P | PTE_W,
+	0x27e000 | PTE_P | PTE_W,
+	0x27f000 | PTE_P | PTE_W,
+	0x280000 | PTE_P | PTE_W,
+	0x281000 | PTE_P | PTE_W,
+	0x282000 | PTE_P | PTE_W,
+	0x283000 | PTE_P | PTE_W,
+	0x284000 | PTE_P | PTE_W,
+	0x285000 | PTE_P | PTE_W,
+	0x286000 | PTE_P | PTE_W,
+	0x287000 | PTE_P | PTE_W,
+	0x288000 | PTE_P | PTE_W,
+	0x289000 | PTE_P | PTE_W,
+	0x28a000 | PTE_P | PTE_W,
+	0x28b000 | PTE_P | PTE_W,
+	0x28c000 | PTE_P | PTE_W,
+	0x28d000 | PTE_P | PTE_W,
+	0x28e000 | PTE_P | PTE_W,
+	0x28f000 | PTE_P | PTE_W,
+	0x290000 | PTE_P | PTE_W,
+	0x291000 | PTE_P | PTE_W,
+	0x292000 | PTE_P | PTE_W,
+	0x293000 | PTE_P | PTE_W,
+	0x294000 | PTE_P | PTE_W,
+	0x295000 | PTE_P | PTE_W,
+	0x296000 | PTE_P | PTE_W,
+	0x297000 | PTE_P | PTE_W,
+	0x298000 | PTE_P | PTE_W,
+	0x299000 | PTE_P | PTE_W,
+	0x29a000 | PTE_P | PTE_W,
+	0x29b000 | PTE_P | PTE_W,
+	0x29c000 | PTE_P | PTE_W,
+	0x29d000 | PTE_P | PTE_W,
+	0x29e000 | PTE_P | PTE_W,
+	0x29f000 | PTE_P | PTE_W,
+	0x2a0000 | PTE_P | PTE_W,
+	0x2a1000 | PTE_P | PTE_W,
+	0x2a2000 | PTE_P | PTE_W,
+	0x2a3000 | PTE_P | PTE_W,
+	0x2a4000 | PTE_P | PTE_W,
+	0x2a5000 | PTE_P | PTE_W,
+	0x2a6000 | PTE_P | PTE_W,
+	0x2a7000 | PTE_P | PTE_W,
+	0x2a8000 | PTE_P | PTE_W,
+	0x2a9000 | PTE_P | PTE_W,
+	0x2aa000 | PTE_P | PTE_W,
+	0x2ab000 | PTE_P | PTE_W,
+	0x2ac000 | PTE_P | PTE_W,
+	0x2ad000 | PTE_P | PTE_W,
+	0x2ae000 | PTE_P | PTE_W,
+	0x2af000 | PTE_P | PTE_W,
+	0x2b0000 | PTE_P | PTE_W,
+	0x2b1000 | PTE_P | PTE_W,
+	0x2b2000 | PTE_P | PTE_W,
+	0x2b3000 | PTE_P | PTE_W,
+	0x2b4000 | PTE_P | PTE_W,
+	0x2b5000 | PTE_P | PTE_W,
+	0x2b6000 | PTE_P | PTE_W,
+	0x2b7000 | PTE_P | PTE_W,
+	0x2b8000 | PTE_P | PTE_W,
+	0x2b9000 | PTE_P | PTE_W,
+	0x2ba000 | PTE_P | PTE_W,
+	0x2bb000 | PTE_P | PTE_W,
+	0x2bc000 | PTE_P | PTE_W,
+	0x2bd000 | PTE_P | PTE_W,
+	0x2be000 | PTE_P | PTE_W,
+	0x2bf000 | PTE_P | PTE_W,
+	0x2c0000 | PTE_P | PTE_W,
+	0x2c1000 | PTE_P | PTE_W,
+	0x2c2000 | PTE_P | PTE_W,
+	0x2c3000 | PTE_P | PTE_W,
+	0x2c4000 | PTE_P | PTE_W,
+	0x2c5000 | PTE_P | PTE_W,
+	0x2c6000 | PTE_P | PTE_W,
+	0x2c7000 | PTE_P | PTE_W,
+	0x2c8000 | PTE_P | PTE_W,
+	0x2c9000 | PTE_P | PTE_W,
+	0x2ca000 | PTE_P | PTE_W,
+	0x2cb000 | PTE_P | PTE_W,
+	0x2cc000 | PTE_P | PTE_W,
+	0x2cd000 | PTE_P | PTE_W,
+	0x2ce000 | PTE_P | PTE_W,
+	0x2cf000 | PTE_P | PTE_W,
+	0x2d0000 | PTE_P | PTE_W,
+	0x2d1000 | PTE_P | PTE_W,
+	0x2d2000 | PTE_P | PTE_W,
+	0x2d3000 | PTE_P | PTE_W,
+	0x2d4000 | PTE_P | PTE_W,
+	0x2d5000 | PTE_P | PTE_W,
+	0x2d6000 | PTE_P | PTE_W,
+	0x2d7000 | PTE_P | PTE_W,
+	0x2d8000 | PTE_P | PTE_W,
+	0x2d9000 | PTE_P | PTE_W,
+	0x2da000 | PTE_P | PTE_W,
+	0x2db000 | PTE_P | PTE_W,
+	0x2dc000 | PTE_P | PTE_W,
+	0x2dd000 | PTE_P | PTE_W,
+	0x2de000 | PTE_P | PTE_W,
+	0x2df000 | PTE_P | PTE_W,
+	0x2e0000 | PTE_P | PTE_W,
+	0x2e1000 | PTE_P | PTE_W,
+	0x2e2000 | PTE_P | PTE_W,
+	0x2e3000 | PTE_P | PTE_W,
+	0x2e4000 | PTE_P | PTE_W,
+	0x2e5000 | PTE_P | PTE_W,
+	0x2e6000 | PTE_P | PTE_W,
+	0x2e7000 | PTE_P | PTE_W,
+	0x2e8000 | PTE_P | PTE_W,
+	0x2e9000 | PTE_P | PTE_W,
+	0x2ea000 | PTE_P | PTE_W,
+	0x2eb000 | PTE_P | PTE_W,
+	0x2ec000 | PTE_P | PTE_W,
+	0x2ed000 | PTE_P | PTE_W,
+	0x2ee000 | PTE_P | PTE_W,
+	0x2ef000 | PTE_P | PTE_W,
+	0x2f0000 | PTE_P | PTE_W,
+	0x2f1000 | PTE_P | PTE_W,
+	0x2f2000 | PTE_P | PTE_W,
+	0x2f3000 | PTE_P | PTE_W,
+	0x2f4000 | PTE_P | PTE_W,
+	0x2f5000 | PTE_P | PTE_W,
+	0x2f6000 | PTE_P | PTE_W,
+	0x2f7000 | PTE_P | PTE_W,
+	0x2f8000 | PTE_P | PTE_W,
+	0x2f9000 | PTE_P | PTE_W,
+	0x2fa000 | PTE_P | PTE_W,
+	0x2fb000 | PTE_P | PTE_W,
+	0x2fc000 | PTE_P | PTE_W,
+	0x2fd000 | PTE_P | PTE_W,
+	0x2fe000 | PTE_P | PTE_W,
+	0x2ff000 | PTE_P | PTE_W,
+	0x300000 | PTE_P | PTE_W,
+	0x301000 | PTE_P | PTE_W,
+	0x302000 | PTE_P | PTE_W,
+	0x303000 | PTE_P | PTE_W,
+	0x304000 | PTE_P | PTE_W,
+	0x305000 | PTE_P | PTE_W,
+	0x306000 | PTE_P | PTE_W,
+	0x307000 | PTE_P | PTE_W,
+	0x308000 | PTE_P | PTE_W,
+	0x309000 | PTE_P | PTE_W,
+	0x30a000 | PTE_P | PTE_W,
+	0x30b000 | PTE_P | PTE_W,
+	0x30c000 | PTE_P | PTE_W,
+	0x30d000 | PTE_P | PTE_W,
+	0x30e000 | PTE_P | PTE_W,
+	0x30f000 | PTE_P | PTE_W,
+	0x310000 | PTE_P | PTE_W,
+	0x311000 | PTE_P | PTE_W,
+	0x312000 | PTE_P | PTE_W,
+	0x313000 | PTE_P | PTE_W,
+	0x314000 | PTE_P | PTE_W,
+	0x315000 | PTE_P | PTE_W,
+	0x316000 | PTE_P | PTE_W,
+	0x317000 | PTE_P | PTE_W,
+	0x318000 | PTE_P | PTE_W,
+	0x319000 | PTE_P | PTE_W,
+	0x31a000 | PTE_P | PTE_W,
+	0x31b000 | PTE_P | PTE_W,
+	0x31c000 | PTE_P | PTE_W,
+	0x31d000 | PTE_P | PTE_W,
+	0x31e000 | PTE_P | PTE_W,
+	0x31f000 | PTE_P | PTE_W,
+	0x320000 | PTE_P | PTE_W,
+	0x321000 | PTE_P | PTE_W,
+	0x322000 | PTE_P | PTE_W,
+	0x323000 | PTE_P | PTE_W,
+	0x324000 | PTE_P | PTE_W,
+	0x325000 | PTE_P | PTE_W,
+	0x326000 | PTE_P | PTE_W,
+	0x327000 | PTE_P | PTE_W,
+	0x328000 | PTE_P | PTE_W,
+	0x329000 | PTE_P | PTE_W,
+	0x32a000 | PTE_P | PTE_W,
+	0x32b000 | PTE_P | PTE_W,
+	0x32c000 | PTE_P | PTE_W,
+	0x32d000 | PTE_P | PTE_W,
+	0x32e000 | PTE_P | PTE_W,
+	0x32f000 | PTE_P | PTE_W,
+	0x330000 | PTE_P | PTE_W,
+	0x331000 | PTE_P | PTE_W,
+	0x332000 | PTE_P | PTE_W,
+	0x333000 | PTE_P | PTE_W,
+	0x334000 | PTE_P | PTE_W,
+	0x335000 | PTE_P | PTE_W,
+	0x336000 | PTE_P | PTE_W,
+	0x337000 | PTE_P | PTE_W,
+	0x338000 | PTE_P | PTE_W,
+	0x339000 | PTE_P | PTE_W,
+	0x33a000 | PTE_P | PTE_W,
+	0x33b000 | PTE_P | PTE_W,
+	0x33c000 | PTE_P | PTE_W,
+	0x33d000 | PTE_P | PTE_W,
+	0x33e000 | PTE_P | PTE_W,
+	0x33f000 | PTE_P | PTE_W,
+	0x340000 | PTE_P | PTE_W,
+	0x341000 | PTE_P | PTE_W,
+	0x342000 | PTE_P | PTE_W,
+	0x343000 | PTE_P | PTE_W,
+	0x344000 | PTE_P | PTE_W,
+	0x345000 | PTE_P | PTE_W,
+	0x346000 | PTE_P | PTE_W,
+	0x347000 | PTE_P | PTE_W,
+	0x348000 | PTE_P | PTE_W,
+	0x349000 | PTE_P | PTE_W,
+	0x34a000 | PTE_P | PTE_W,
+	0x34b000 | PTE_P | PTE_W,
+	0x34c000 | PTE_P | PTE_W,
+	0x34d000 | PTE_P | PTE_W,
+	0x34e000 | PTE_P | PTE_W,
+	0x34f000 | PTE_P | PTE_W,
+	0x350000 | PTE_P | PTE_W,
+	0x351000 | PTE_P | PTE_W,
+	0x352000 | PTE_P | PTE_W,
+	0x353000 | PTE_P | PTE_W,
+	0x354000 | PTE_P | PTE_W,
+	0x355000 | PTE_P | PTE_W,
+	0x356000 | PTE_P | PTE_W,
+	0x357000 | PTE_P | PTE_W,
+	0x358000 | PTE_P | PTE_W,
+	0x359000 | PTE_P | PTE_W,
+	0x35a000 | PTE_P | PTE_W,
+	0x35b000 | PTE_P | PTE_W,
+	0x35c000 | PTE_P | PTE_W,
+	0x35d000 | PTE_P | PTE_W,
+	0x35e000 | PTE_P | PTE_W,
+	0x35f000 | PTE_P | PTE_W,
+	0x360000 | PTE_P | PTE_W,
+	0x361000 | PTE_P | PTE_W,
+	0x362000 | PTE_P | PTE_W,
+	0x363000 | PTE_P | PTE_W,
+	0x364000 | PTE_P | PTE_W,
+	0x365000 | PTE_P | PTE_W,
+	0x366000 | PTE_P | PTE_W,
+	0x367000 | PTE_P | PTE_W,
+	0x368000 | PTE_P | PTE_W,
+	0x369000 | PTE_P | PTE_W,
+	0x36a000 | PTE_P | PTE_W,
+	0x36b000 | PTE_P | PTE_W,
+	0x36c000 | PTE_P | PTE_W,
+	0x36d000 | PTE_P | PTE_W,
+	0x36e000 | PTE_P | PTE_W,
+	0x36f000 | PTE_P | PTE_W,
+	0x370000 | PTE_P | PTE_W,
+	0x371000 | PTE_P | PTE_W,
+	0x372000 | PTE_P | PTE_W,
+	0x373000 | PTE_P | PTE_W,
+	0x374000 | PTE_P | PTE_W,
+	0x375000 | PTE_P | PTE_W,
+	0x376000 | PTE_P | PTE_W,
+	0x377000 | PTE_P | PTE_W,
+	0x378000 | PTE_P | PTE_W,
+	0x379000 | PTE_P | PTE_W,
+	0x37a000 | PTE_P | PTE_W,
+	0x37b000 | PTE_P | PTE_W,
+	0x37c000 | PTE_P | PTE_W,
+	0x37d000 | PTE_P | PTE_W,
+	0x37e000 | PTE_P | PTE_W,
+	0x37f000 | PTE_P | PTE_W,
+	0x380000 | PTE_P | PTE_W,
+	0x381000 | PTE_P | PTE_W,
+	0x382000 | PTE_P | PTE_W,
+	0x383000 | PTE_P | PTE_W,
+	0x384000 | PTE_P | PTE_W,
+	0x385000 | PTE_P | PTE_W,
+	0x386000 | PTE_P | PTE_W,
+	0x387000 | PTE_P | PTE_W,
+	0x388000 | PTE_P | PTE_W,
+	0x389000 | PTE_P | PTE_W,
+	0x38a000 | PTE_P | PTE_W,
+	0x38b000 | PTE_P | PTE_W,
+	0x38c000 | PTE_P | PTE_W,
+	0x38d000 | PTE_P | PTE_W,
+	0x38e000 | PTE_P | PTE_W,
+	0x38f000 | PTE_P | PTE_W,
+	0x390000 | PTE_P | PTE_W,
+	0x391000 | PTE_P | PTE_W,
+	0x392000 | PTE_P | PTE_W,
+	0x393000 | PTE_P | PTE_W,
+	0x394000 | PTE_P | PTE_W,
+	0x395000 | PTE_P | PTE_W,
+	0x396000 | PTE_P | PTE_W,
+	0x397000 | PTE_P | PTE_W,
+	0x398000 | PTE_P | PTE_W,
+	0x399000 | PTE_P | PTE_W,
+	0x39a000 | PTE_P | PTE_W,
+	0x39b000 | PTE_P | PTE_W,
+	0x39c000 | PTE_P | PTE_W,
+	0x39d000 | PTE_P | PTE_W,
+	0x39e000 | PTE_P | PTE_W,
+	0x39f000 | PTE_P | PTE_W,
+	0x3a0000 | PTE_P | PTE_W,
+	0x3a1000 | PTE_P | PTE_W,
+	0x3a2000 | PTE_P | PTE_W,
+	0x3a3000 | PTE_P | PTE_W,
+	0x3a4000 | PTE_P | PTE_W,
+	0x3a5000 | PTE_P | PTE_W,
+	0x3a6000 | PTE_P | PTE_W,
+	0x3a7000 | PTE_P | PTE_W,
+	0x3a8000 | PTE_P | PTE_W,
+	0x3a9000 | PTE_P | PTE_W,
+	0x3aa000 | PTE_P | PTE_W,
+	0x3ab000 | PTE_P | PTE_W,
+	0x3ac000 | PTE_P | PTE_W,
+	0x3ad000 | PTE_P | PTE_W,
+	0x3ae000 | PTE_P | PTE_W,
+	0x3af000 | PTE_P | PTE_W,
+	0x3b0000 | PTE_P | PTE_W,
+	0x3b1000 | PTE_P | PTE_W,
+	0x3b2000 | PTE_P | PTE_W,
+	0x3b3000 | PTE_P | PTE_W,
+	0x3b4000 | PTE_P | PTE_W,
+	0x3b5000 | PTE_P | PTE_W,
+	0x3b6000 | PTE_P | PTE_W,
+	0x3b7000 | PTE_P | PTE_W,
+	0x3b8000 | PTE_P | PTE_W,
+	0x3b9000 | PTE_P | PTE_W,
+	0x3ba000 | PTE_P | PTE_W,
+	0x3bb000 | PTE_P | PTE_W,
+	0x3bc000 | PTE_P | PTE_W,
+	0x3bd000 | PTE_P | PTE_W,
+	0x3be000 | PTE_P | PTE_W,
+	0x3bf000 | PTE_P | PTE_W,
+	0x3c0000 | PTE_P | PTE_W,
+	0x3c1000 | PTE_P | PTE_W,
+	0x3c2000 | PTE_P | PTE_W,
+	0x3c3000 | PTE_P | PTE_W,
+	0x3c4000 | PTE_P | PTE_W,
+	0x3c5000 | PTE_P | PTE_W,
+	0x3c6000 | PTE_P | PTE_W,
+	0x3c7000 | PTE_P | PTE_W,
+	0x3c8000 | PTE_P | PTE_W,
+	0x3c9000 | PTE_P | PTE_W,
+	0x3ca000 | PTE_P | PTE_W,
+	0x3cb000 | PTE_P | PTE_W,
+	0x3cc000 | PTE_P | PTE_W,
+	0x3cd000 | PTE_P | PTE_W,
+	0x3ce000 | PTE_P | PTE_W,
+	0x3cf000 | PTE_P | PTE_W,
+	0x3d0000 | PTE_P | PTE_W,
+	0x3d1000 | PTE_P | PTE_W,
+	0x3d2000 | PTE_P | PTE_W,
+	0x3d3000 | PTE_P | PTE_W,
+	0x3d4000 | PTE_P | PTE_W,
+	0x3d5000 | PTE_P | PTE_W,
+	0x3d6000 | PTE_P | PTE_W,
+	0x3d7000 | PTE_P | PTE_W,
+	0x3d8000 | PTE_P | PTE_W,
+	0x3d9000 | PTE_P | PTE_W,
+	0x3da000 | PTE_P | PTE_W,
+	0x3db000 | PTE_P | PTE_W,
+	0x3dc000 | PTE_P | PTE_W,
+	0x3dd000 | PTE_P | PTE_W,
+	0x3de000 | PTE_P | PTE_W,
+	0x3df000 | PTE_P | PTE_W,
+	0x3e0000 | PTE_P | PTE_W,
+	0x3e1000 | PTE_P | PTE_W,
+	0x3e2000 | PTE_P | PTE_W,
+	0x3e3000 | PTE_P | PTE_W,
+	0x3e4000 | PTE_P | PTE_W,
+	0x3e5000 | PTE_P | PTE_W,
+	0x3e6000 | PTE_P | PTE_W,
+	0x3e7000 | PTE_P | PTE_W,
+	0x3e8000 | PTE_P | PTE_W,
+	0x3e9000 | PTE_P | PTE_W,
+	0x3ea000 | PTE_P | PTE_W,
+	0x3eb000 | PTE_P | PTE_W,
+	0x3ec000 | PTE_P | PTE_W,
+	0x3ed000 | PTE_P | PTE_W,
+	0x3ee000 | PTE_P | PTE_W,
+	0x3ef000 | PTE_P | PTE_W,
+	0x3f0000 | PTE_P | PTE_W,
+	0x3f1000 | PTE_P | PTE_W,
+	0x3f2000 | PTE_P | PTE_W,
+	0x3f3000 | PTE_P | PTE_W,
+	0x3f4000 | PTE_P | PTE_W,
+	0x3f5000 | PTE_P | PTE_W,
+	0x3f6000 | PTE_P | PTE_W,
+	0x3f7000 | PTE_P | PTE_W,
+	0x3f8000 | PTE_P | PTE_W,
+	0x3f9000 | PTE_P | PTE_W,
+	0x3fa000 | PTE_P | PTE_W,
+	0x3fb000 | PTE_P | PTE_W,
+	0x3fc000 | PTE_P | PTE_W,
+	0x3fd000 | PTE_P | PTE_W,
+	0x3fe000 | PTE_P | PTE_W,
+	0x3ff000 | PTE_P | PTE_W,
+};
+
diff --git a/kern/init.c b/kern/init.c
new file mode 100644
index 0000000..30cb91d
--- /dev/null
+++ b/kern/init.c
@@ -0,0 +1,92 @@
+/* See COPYRIGHT for copyright information. */
+
+#include <inc/stdio.h>
+#include <inc/string.h>
+#include <inc/assert.h>
+
+#include <kern/monitor.h>
+#include <kern/console.h>
+
+// Test the stack backtrace function (lab 1 only)
+void
+test_backtrace(int x)
+{
+	cprintf("entering test_backtrace %d\n", x);
+	if (x > 0)
+		test_backtrace(x-1);
+	else
+		mon_backtrace(0, 0, 0);
+	cprintf("leaving test_backtrace %d\n", x);
+}
+
+void
+i386_init(void)
+{
+	extern char edata[], end[];
+
+	// Before doing anything else, complete the ELF loading process.
+	// Clear the uninitialized global data (BSS) section of our program.
+	// This ensures that all static/global variables start out zero.
+	memset(edata, 0, end - edata);
+
+	// Initialize the console.
+	// Can't call cprintf until after we do this!
+	cons_init();
+
+	cprintf("6828 decimal is %o octal!\n", 6828);
+
+	// Test the stack backtrace function (lab 1 only)
+	test_backtrace(5);
+
+	// Drop into the kernel monitor.
+	while (1)
+		monitor(NULL);
+}
+
+
+/*
+ * Variable panicstr contains argument to first call to panic; used as flag
+ * to indicate that the kernel has already called panic.
+ */
+const char *panicstr;
+
+/*
+ * Panic is called on unresolvable fatal errors.
+ * It prints "panic: mesg", and then enters the kernel monitor.
+ */
+void
+_panic(const char *file, int line, const char *fmt,...)
+{
+	va_list ap;
+
+	if (panicstr)
+		goto dead;
+	panicstr = fmt;
+
+	// Be extra sure that the machine is in as reasonable state
+	asm volatile("cli; cld");
+
+	va_start(ap, fmt);
+	cprintf("kernel panic at %s:%d: ", file, line);
+	vcprintf(fmt, ap);
+	cprintf("\n");
+	va_end(ap);
+
+dead:
+	/* break into the kernel monitor */
+	while (1)
+		monitor(NULL);
+}
+
+/* like panic, but don't */
+void
+_warn(const char *file, int line, const char *fmt,...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	cprintf("kernel warning at %s:%d: ", file, line);
+	vcprintf(fmt, ap);
+	cprintf("\n");
+	va_end(ap);
+}
diff --git a/kern/kdebug.c b/kern/kdebug.c
new file mode 100644
index 0000000..9547143
--- /dev/null
+++ b/kern/kdebug.c
@@ -0,0 +1,206 @@
+#include <inc/stab.h>
+#include <inc/string.h>
+#include <inc/memlayout.h>
+#include <inc/assert.h>
+
+#include <kern/kdebug.h>
+
+extern const struct Stab __STAB_BEGIN__[];	// Beginning of stabs table
+extern const struct Stab __STAB_END__[];	// End of stabs table
+extern const char __STABSTR_BEGIN__[];		// Beginning of string table
+extern const char __STABSTR_END__[];		// End of string table
+
+
+// stab_binsearch(stabs, region_left, region_right, type, addr)
+//
+//	Some stab types are arranged in increasing order by instruction
+//	address.  For example, N_FUN stabs (stab entries with n_type ==
+//	N_FUN), which mark functions, and N_SO stabs, which mark source files.
+//
+//	Given an instruction address, this function finds the single stab
+//	entry of type 'type' that contains that address.
+//
+//	The search takes place within the range [*region_left, *region_right].
+//	Thus, to search an entire set of N stabs, you might do:
+//
+//		left = 0;
+//		right = N - 1;     /* rightmost stab */
+//		stab_binsearch(stabs, &left, &right, type, addr);
+//
+//	The search modifies *region_left and *region_right to bracket the
+//	'addr'.  *region_left points to the matching stab that contains
+//	'addr', and *region_right points just before the next stab.  If
+//	*region_left > *region_right, then 'addr' is not contained in any
+//	matching stab.
+//
+//	For example, given these N_SO stabs:
+//		Index  Type   Address
+//		0      SO     f0100000
+//		13     SO     f0100040
+//		117    SO     f0100176
+//		118    SO     f0100178
+//		555    SO     f0100652
+//		556    SO     f0100654
+//		657    SO     f0100849
+//	this code:
+//		left = 0, right = 657;
+//		stab_binsearch(stabs, &left, &right, N_SO, 0xf0100184);
+//	will exit setting left = 118, right = 554.
+//
+static void
+stab_binsearch(const struct Stab *stabs, int *region_left, int *region_right,
+	       int type, uintptr_t addr)
+{
+	int l = *region_left, r = *region_right, any_matches = 0;
+
+	while (l <= r) {
+		int true_m = (l + r) / 2, m = true_m;
+
+		// search for earliest stab with right type
+		while (m >= l && stabs[m].n_type != type)
+			m--;
+		if (m < l) {	// no match in [l, m]
+			l = true_m + 1;
+			continue;
+		}
+
+		// actual binary search
+		any_matches = 1;
+		if (stabs[m].n_value < addr) {
+			*region_left = m;
+			l = true_m + 1;
+		} else if (stabs[m].n_value > addr) {
+			*region_right = m - 1;
+			r = m - 1;
+		} else {
+			// exact match for 'addr', but continue loop to find
+			// *region_right
+			*region_left = m;
+			l = m;
+			addr++;
+		}
+	}
+
+	if (!any_matches)
+		*region_right = *region_left - 1;
+	else {
+		// find rightmost region containing 'addr'
+		for (l = *region_right;
+		     l > *region_left && stabs[l].n_type != type;
+		     l--)
+			/* do nothing */;
+		*region_left = l;
+	}
+}
+
+
+// debuginfo_eip(addr, info)
+//
+//	Fill in the 'info' structure with information about the specified
+//	instruction address, 'addr'.  Returns 0 if information was found, and
+//	negative if not.  But even if it returns negative it has stored some
+//	information into '*info'.
+//
+int
+debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info)
+{
+	const struct Stab *stabs, *stab_end;
+	const char *stabstr, *stabstr_end;
+	int lfile, rfile, lfun, rfun, lline, rline;
+
+	// Initialize *info
+	info->eip_file = "<unknown>";
+	info->eip_line = 0;
+	info->eip_fn_name = "<unknown>";
+	info->eip_fn_namelen = 9;
+	info->eip_fn_addr = addr;
+	info->eip_fn_narg = 0;
+
+	// Find the relevant set of stabs
+	if (addr >= ULIM) {
+		stabs = __STAB_BEGIN__;
+		stab_end = __STAB_END__;
+		stabstr = __STABSTR_BEGIN__;
+		stabstr_end = __STABSTR_END__;
+	} else {
+		// Can't search for user-level addresses yet!
+  	        panic("User address");
+	}
+
+	// String table validity checks
+	if (stabstr_end <= stabstr || stabstr_end[-1] != 0)
+		return -1;
+
+	// Now we find the right stabs that define the function containing
+	// 'eip'.  First, we find the basic source file containing 'eip'.
+	// Then, we look in that source file for the function.  Then we look
+	// for the line number.
+
+	// Search the entire set of stabs for the source file (type N_SO).
+	lfile = 0;
+	rfile = (stab_end - stabs) - 1;
+	stab_binsearch(stabs, &lfile, &rfile, N_SO, addr);
+	if (lfile == 0)
+		return -1;
+
+	// Search within that file's stabs for the function definition
+	// (N_FUN).
+	lfun = lfile;
+	rfun = rfile;
+	stab_binsearch(stabs, &lfun, &rfun, N_FUN, addr);
+
+	if (lfun <= rfun) {
+		// stabs[lfun] points to the function name
+		// in the string table, but check bounds just in case.
+		if (stabs[lfun].n_strx < stabstr_end - stabstr)
+			info->eip_fn_name = stabstr + stabs[lfun].n_strx;
+		info->eip_fn_addr = stabs[lfun].n_value;
+		addr -= info->eip_fn_addr;
+		// Search within the function definition for the line number.
+		lline = lfun;
+		rline = rfun;
+	} else {
+		// Couldn't find function stab!  Maybe we're in an assembly
+		// file.  Search the whole file for the line number.
+		info->eip_fn_addr = addr;
+		lline = lfile;
+		rline = rfile;
+	}
+	// Ignore stuff after the colon.
+	info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name;
+
+
+	// Search within [lline, rline] for the line number stab.
+	// If found, set info->eip_line to the right line number.
+	// If not found, return -1.
+	//
+	// Hint:
+	//	There's a particular stabs type used for line numbers.
+	//	Look at the STABS documentation and <inc/stab.h> to find
+	//	which one.
+	// Your code here.
+
+
+	// Search backwards from the line number for the relevant filename
+	// stab.
+	// We can't just use the "lfile" stab because inlined functions
+	// can interpolate code from a different file!
+	// Such included source files use the N_SOL stab type.
+	while (lline >= lfile
+	       && stabs[lline].n_type != N_SOL
+	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value))
+		lline--;
+	if (lline >= lfile && stabs[lline].n_strx < stabstr_end - stabstr)
+		info->eip_file = stabstr + stabs[lline].n_strx;
+
+
+	// Set eip_fn_narg to the number of arguments taken by the function,
+	// or 0 if there was no containing function.
+	if (lfun < rfun)
+		for (lline = lfun + 1;
+		     lline < rfun && stabs[lline].n_type == N_PSYM;
+		     lline++)
+			info->eip_fn_narg++;
+
+	return 0;
+}
diff --git a/kern/kdebug.h b/kern/kdebug.h
new file mode 100644
index 0000000..236af39
--- /dev/null
+++ b/kern/kdebug.h
@@ -0,0 +1,20 @@
+#ifndef JOS_KERN_KDEBUG_H
+#define JOS_KERN_KDEBUG_H
+
+#include <inc/types.h>
+
+// Debug information about a particular instruction pointer
+struct Eipdebuginfo {
+	const char *eip_file;		// Source code filename for EIP
+	int eip_line;			// Source code linenumber for EIP
+
+	const char *eip_fn_name;	// Name of function containing EIP
+					//  - Note: not null terminated!
+	int eip_fn_namelen;		// Length of function name
+	uintptr_t eip_fn_addr;		// Address of start of function
+	int eip_fn_narg;		// Number of function arguments
+};
+
+int debuginfo_eip(uintptr_t eip, struct Eipdebuginfo *info);
+
+#endif
diff --git a/kern/kernel.ld b/kern/kernel.ld
new file mode 100644
index 0000000..a219d1d
--- /dev/null
+++ b/kern/kernel.ld
@@ -0,0 +1,61 @@
+/* Simple linker script for the JOS kernel.
+   See the GNU ld 'info' manual ("info ld") to learn the syntax. */
+
+OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
+OUTPUT_ARCH(i386)
+ENTRY(_start)
+
+SECTIONS
+{
+	/* Link the kernel at this address: "." means the current address */
+	. = 0xF0100000;
+
+	/* AT(...) gives the load address of this section, which tells
+	   the boot loader where to load the kernel in physical memory */
+	.text : AT(0x100000) {
+		*(.text .stub .text.* .gnu.linkonce.t.*)
+	}
+
+	PROVIDE(etext = .);	/* Define the 'etext' symbol to this value */
+
+	.rodata : {
+		*(.rodata .rodata.* .gnu.linkonce.r.*)
+	}
+
+	/* Include debugging information in kernel memory */
+	.stab : {
+		PROVIDE(__STAB_BEGIN__ = .);
+		*(.stab);
+		PROVIDE(__STAB_END__ = .);
+		BYTE(0)		/* Force the linker to allocate space
+				   for this section */
+	}
+
+	.stabstr : {
+		PROVIDE(__STABSTR_BEGIN__ = .);
+		*(.stabstr);
+		PROVIDE(__STABSTR_END__ = .);
+		BYTE(0)		/* Force the linker to allocate space
+				   for this section */
+	}
+
+	/* Adjust the address for the data segment to the next page */
+	. = ALIGN(0x1000);
+
+	/* The data segment */
+	.data : {
+		*(.data)
+	}
+
+	.bss : {
+		PROVIDE(edata = .);
+		*(.bss)
+		PROVIDE(end = .);
+		BYTE(0)
+	}
+
+
+	/DISCARD/ : {
+		*(.eh_frame .note.GNU-stack)
+	}
+}
diff --git a/kern/monitor.c b/kern/monitor.c
new file mode 100644
index 0000000..e137e92
--- /dev/null
+++ b/kern/monitor.c
@@ -0,0 +1,125 @@
+// Simple command-line kernel monitor useful for
+// controlling the kernel and exploring the system interactively.
+
+#include <inc/stdio.h>
+#include <inc/string.h>
+#include <inc/memlayout.h>
+#include <inc/assert.h>
+#include <inc/x86.h>
+
+#include <kern/console.h>
+#include <kern/monitor.h>
+#include <kern/kdebug.h>
+
+#define CMDBUF_SIZE	80	// enough for one VGA text line
+
+
+struct Command {
+	const char *name;
+	const char *desc;
+	// return -1 to force monitor to exit
+	int (*func)(int argc, char** argv, struct Trapframe* tf);
+};
+
+static struct Command commands[] = {
+	{ "help", "Display this list of commands", mon_help },
+	{ "kerninfo", "Display information about the kernel", mon_kerninfo },
+};
+
+/***** Implementations of basic kernel monitor commands *****/
+
+int
+mon_help(int argc, char **argv, struct Trapframe *tf)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(commands); i++)
+		cprintf("%s - %s\n", commands[i].name, commands[i].desc);
+	return 0;
+}
+
+int
+mon_kerninfo(int argc, char **argv, struct Trapframe *tf)
+{
+	extern char _start[], entry[], etext[], edata[], end[];
+
+	cprintf("Special kernel symbols:\n");
+	cprintf("  _start                  %08x (phys)\n", _start);
+	cprintf("  entry  %08x (virt)  %08x (phys)\n", entry, entry - KERNBASE);
+	cprintf("  etext  %08x (virt)  %08x (phys)\n", etext, etext - KERNBASE);
+	cprintf("  edata  %08x (virt)  %08x (phys)\n", edata, edata - KERNBASE);
+	cprintf("  end    %08x (virt)  %08x (phys)\n", end, end - KERNBASE);
+	cprintf("Kernel executable memory footprint: %dKB\n",
+		ROUNDUP(end - entry, 1024) / 1024);
+	return 0;
+}
+
+int
+mon_backtrace(int argc, char **argv, struct Trapframe *tf)
+{
+	// Your code here.
+	return 0;
+}
+
+
+
+/***** Kernel monitor command interpreter *****/
+
+#define WHITESPACE "\t\r\n "
+#define MAXARGS 16
+
+static int
+runcmd(char *buf, struct Trapframe *tf)
+{
+	int argc;
+	char *argv[MAXARGS];
+	int i;
+
+	// Parse the command buffer into whitespace-separated arguments
+	argc = 0;
+	argv[argc] = 0;
+	while (1) {
+		// gobble whitespace
+		while (*buf && strchr(WHITESPACE, *buf))
+			*buf++ = 0;
+		if (*buf == 0)
+			break;
+
+		// save and scan past next arg
+		if (argc == MAXARGS-1) {
+			cprintf("Too many arguments (max %d)\n", MAXARGS);
+			return 0;
+		}
+		argv[argc++] = buf;
+		while (*buf && !strchr(WHITESPACE, *buf))
+			buf++;
+	}
+	argv[argc] = 0;
+
+	// Lookup and invoke the command
+	if (argc == 0)
+		return 0;
+	for (i = 0; i < ARRAY_SIZE(commands); i++) {
+		if (strcmp(argv[0], commands[i].name) == 0)
+			return commands[i].func(argc, argv, tf);
+	}
+	cprintf("Unknown command '%s'\n", argv[0]);
+	return 0;
+}
+
+void
+monitor(struct Trapframe *tf)
+{
+	char *buf;
+
+	cprintf("Welcome to the JOS kernel monitor!\n");
+	cprintf("Type 'help' for a list of commands.\n");
+
+
+	while (1) {
+		buf = readline("K> ");
+		if (buf != NULL)
+			if (runcmd(buf, tf) < 0)
+				break;
+	}
+}
diff --git a/kern/monitor.h b/kern/monitor.h
new file mode 100644
index 0000000..0aa0f26
--- /dev/null
+++ b/kern/monitor.h
@@ -0,0 +1,19 @@
+#ifndef JOS_KERN_MONITOR_H
+#define JOS_KERN_MONITOR_H
+#ifndef JOS_KERNEL
+# error "This is a JOS kernel header; user programs should not #include it"
+#endif
+
+struct Trapframe;
+
+// Activate the kernel monitor,
+// optionally providing a trap frame indicating the current state
+// (NULL if none).
+void monitor(struct Trapframe *tf);
+
+// Functions implementing monitor commands.
+int mon_help(int argc, char **argv, struct Trapframe *tf);
+int mon_kerninfo(int argc, char **argv, struct Trapframe *tf);
+int mon_backtrace(int argc, char **argv, struct Trapframe *tf);
+
+#endif	// !JOS_KERN_MONITOR_H
diff --git a/kern/printf.c b/kern/printf.c
new file mode 100644
index 0000000..6932ca5
--- /dev/null
+++ b/kern/printf.c
@@ -0,0 +1,37 @@
+// Simple implementation of cprintf console output for the kernel,
+// based on printfmt() and the kernel console's cputchar().
+
+#include <inc/types.h>
+#include <inc/stdio.h>
+#include <inc/stdarg.h>
+
+
+static void
+putch(int ch, int *cnt)
+{
+	cputchar(ch);
+	*cnt++;
+}
+
+int
+vcprintf(const char *fmt, va_list ap)
+{
+	int cnt = 0;
+
+	vprintfmt((void*)putch, &cnt, fmt, ap);
+	return cnt;
+}
+
+int
+cprintf(const char *fmt, ...)
+{
+	va_list ap;
+	int cnt;
+
+	va_start(ap, fmt);
+	cnt = vcprintf(fmt, ap);
+	va_end(ap);
+
+	return cnt;
+}
+
diff --git a/lib/printfmt.c b/lib/printfmt.c
new file mode 100644
index 0000000..28e01c9
--- /dev/null
+++ b/lib/printfmt.c
@@ -0,0 +1,300 @@
+// Stripped-down primitive printf-style formatting routines,
+// used in common by printf, sprintf, fprintf, etc.
+// This code is also used by both the kernel and user programs.
+
+#include <inc/types.h>
+#include <inc/stdio.h>
+#include <inc/string.h>
+#include <inc/stdarg.h>
+#include <inc/error.h>
+
+/*
+ * Space or zero padding and a field width are supported for the numeric
+ * formats only.
+ *
+ * The special format %e takes an integer error code
+ * and prints a string describing the error.
+ * The integer may be positive or negative,
+ * so that -E_NO_MEM and E_NO_MEM are equivalent.
+ */
+
+static const char * const error_string[MAXERROR] =
+{
+	[E_UNSPECIFIED]	= "unspecified error",
+	[E_BAD_ENV]	= "bad environment",
+	[E_INVAL]	= "invalid parameter",
+	[E_NO_MEM]	= "out of memory",
+	[E_NO_FREE_ENV]	= "out of environments",
+	[E_FAULT]	= "segmentation fault",
+};
+
+/*
+ * Print a number (base <= 16) in reverse order,
+ * using specified putch function and associated pointer putdat.
+ */
+static void
+printnum(void (*putch)(int, void*), void *putdat,
+	 unsigned long long num, unsigned base, int width, int padc)
+{
+	// first recursively print all preceding (more significant) digits
+	if (num >= base) {
+		printnum(putch, putdat, num / base, base, width - 1, padc);
+	} else {
+		// print any needed pad characters before first digit
+		while (--width > 0)
+			putch(padc, putdat);
+	}
+
+	// then print this (the least significant) digit
+	putch("0123456789abcdef"[num % base], putdat);
+}
+
+// Get an unsigned int of various possible sizes from a varargs list,
+// depending on the lflag parameter.
+static unsigned long long
+getuint(va_list *ap, int lflag)
+{
+	if (lflag >= 2)
+		return va_arg(*ap, unsigned long long);
+	else if (lflag)
+		return va_arg(*ap, unsigned long);
+	else
+		return va_arg(*ap, unsigned int);
+}
+
+// Same as getuint but signed - can't use getuint
+// because of sign extension
+static long long
+getint(va_list *ap, int lflag)
+{
+	if (lflag >= 2)
+		return va_arg(*ap, long long);
+	else if (lflag)
+		return va_arg(*ap, long);
+	else
+		return va_arg(*ap, int);
+}
+
+
+// Main function to format and print a string.
+void printfmt(void (*putch)(int, void*), void *putdat, const char *fmt, ...);
+
+void
+vprintfmt(void (*putch)(int, void*), void *putdat, const char *fmt, va_list ap)
+{
+	register const char *p;
+	register int ch, err;
+	unsigned long long num;
+	int base, lflag, width, precision, altflag;
+	char padc;
+
+	while (1) {
+		while ((ch = *(unsigned char *) fmt++) != '%') {
+			if (ch == '\0')
+				return;
+			putch(ch, putdat);
+		}
+
+		// Process a %-escape sequence
+		padc = ' ';
+		width = -1;
+		precision = -1;
+		lflag = 0;
+		altflag = 0;
+	reswitch:
+		switch (ch = *(unsigned char *) fmt++) {
+
+		// flag to pad on the right
+		case '-':
+			padc = '-';
+			goto reswitch;
+
+		// flag to pad with 0's instead of spaces
+		case '0':
+			padc = '0';
+			goto reswitch;
+
+		// width field
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			for (precision = 0; ; ++fmt) {
+				precision = precision * 10 + ch - '0';
+				ch = *fmt;
+				if (ch < '0' || ch > '9')
+					break;
+			}
+			goto process_precision;
+
+		case '*':
+			precision = va_arg(ap, int);
+			goto process_precision;
+
+		case '.':
+			if (width < 0)
+				width = 0;
+			goto reswitch;
+
+		case '#':
+			altflag = 1;
+			goto reswitch;
+
+		process_precision:
+			if (width < 0)
+				width = precision, precision = -1;
+			goto reswitch;
+
+		// long flag (doubled for long long)
+		case 'l':
+			lflag++;
+			goto reswitch;
+
+		// character
+		case 'c':
+			putch(va_arg(ap, int), putdat);
+			break;
+
+		// error message
+		case 'e':
+			err = va_arg(ap, int);
+			if (err < 0)
+				err = -err;
+			if (err >= MAXERROR || (p = error_string[err]) == NULL)
+				printfmt(putch, putdat, "error %d", err);
+			else
+				printfmt(putch, putdat, "%s", p);
+			break;
+
+		// string
+		case 's':
+			if ((p = va_arg(ap, char *)) == NULL)
+				p = "(null)";
+			if (width > 0 && padc != '-')
+				for (width -= strnlen(p, precision); width > 0; width--)
+					putch(padc, putdat);
+			for (; (ch = *p++) != '\0' && (precision < 0 || --precision >= 0); width--)
+				if (altflag && (ch < ' ' || ch > '~'))
+					putch('?', putdat);
+				else
+					putch(ch, putdat);
+			for (; width > 0; width--)
+				putch(' ', putdat);
+			break;
+
+		// (signed) decimal
+		case 'd':
+			num = getint(&ap, lflag);
+			if ((long long) num < 0) {
+				putch('-', putdat);
+				num = -(long long) num;
+			}
+			base = 10;
+			goto number;
+
+		// unsigned decimal
+		case 'u':
+			num = getuint(&ap, lflag);
+			base = 10;
+			goto number;
+
+		// (unsigned) octal
+		case 'o':
+			// Replace this with your code.
+			putch('X', putdat);
+			putch('X', putdat);
+			putch('X', putdat);
+			break;
+
+		// pointer
+		case 'p':
+			putch('0', putdat);
+			putch('x', putdat);
+			num = (unsigned long long)
+				(uintptr_t) va_arg(ap, void *);
+			base = 16;
+			goto number;
+
+		// (unsigned) hexadecimal
+		case 'x':
+			num = getuint(&ap, lflag);
+			base = 16;
+		number:
+			printnum(putch, putdat, num, base, width, padc);
+			break;
+
+		// escaped '%' character
+		case '%':
+			putch(ch, putdat);
+			break;
+
+		// unrecognized escape sequence - just print it literally
+		default:
+			putch('%', putdat);
+			for (fmt--; fmt[-1] != '%'; fmt--)
+				/* do nothing */;
+			break;
+		}
+	}
+}
+
+void
+printfmt(void (*putch)(int, void*), void *putdat, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	vprintfmt(putch, putdat, fmt, ap);
+	va_end(ap);
+}
+
+struct sprintbuf {
+	char *buf;
+	char *ebuf;
+	int cnt;
+};
+
+static void
+sprintputch(int ch, struct sprintbuf *b)
+{
+	b->cnt++;
+	if (b->buf < b->ebuf)
+		*b->buf++ = ch;
+}
+
+int
+vsnprintf(char *buf, int n, const char *fmt, va_list ap)
+{
+	struct sprintbuf b = {buf, buf+n-1, 0};
+
+	if (buf == NULL || n < 1)
+		return -E_INVAL;
+
+	// print the string to the buffer
+	vprintfmt((void*)sprintputch, &b, fmt, ap);
+
+	// null terminate the buffer
+	*b.buf = '\0';
+
+	return b.cnt;
+}
+
+int
+snprintf(char *buf, int n, const char *fmt, ...)
+{
+	va_list ap;
+	int rc;
+
+	va_start(ap, fmt);
+	rc = vsnprintf(buf, n, fmt, ap);
+	va_end(ap);
+
+	return rc;
+}
+
+
diff --git a/lib/readline.c b/lib/readline.c
new file mode 100644
index 0000000..bc77b1f
--- /dev/null
+++ b/lib/readline.c
@@ -0,0 +1,38 @@
+#include <inc/stdio.h>
+#include <inc/error.h>
+
+#define BUFLEN 1024
+static char buf[BUFLEN];
+
+char *
+readline(const char *prompt)
+{
+	int i, c, echoing;
+
+	if (prompt != NULL)
+		cprintf("%s", prompt);
+
+	i = 0;
+	echoing = iscons(0);
+	while (1) {
+		c = getchar();
+		if (c < 0) {
+			cprintf("read error: %e\n", c);
+			return NULL;
+		} else if ((c == '\b' || c == '\x7f') && i > 0) {
+			if (echoing)
+				cputchar('\b');
+			i--;
+		} else if (c >= ' ' && i < BUFLEN-1) {
+			if (echoing)
+				cputchar(c);
+			buf[i++] = c;
+		} else if (c == '\n' || c == '\r') {
+			if (echoing)
+				cputchar('\n');
+			buf[i] = 0;
+			return buf;
+		}
+	}
+}
+
diff --git a/lib/string.c b/lib/string.c
new file mode 100644
index 0000000..400547f
--- /dev/null
+++ b/lib/string.c
@@ -0,0 +1,285 @@
+// Basic string routines.  Not hardware optimized, but not shabby.
+
+#include <inc/string.h>
+
+// Using assembly for memset/memmove
+// makes some difference on real hardware,
+// but it makes an even bigger difference on bochs.
+// Primespipe runs 3x faster this way.
+#define ASM 1
+
+int
+strlen(const char *s)
+{
+	int n;
+
+	for (n = 0; *s != '\0'; s++)
+		n++;
+	return n;
+}
+
+int
+strnlen(const char *s, size_t size)
+{
+	int n;
+
+	for (n = 0; size > 0 && *s != '\0'; s++, size--)
+		n++;
+	return n;
+}
+
+char *
+strcpy(char *dst, const char *src)
+{
+	char *ret;
+
+	ret = dst;
+	while ((*dst++ = *src++) != '\0')
+		/* do nothing */;
+	return ret;
+}
+
+char *
+strcat(char *dst, const char *src)
+{
+	int len = strlen(dst);
+	strcpy(dst + len, src);
+	return dst;
+}
+
+char *
+strncpy(char *dst, const char *src, size_t size) {
+	size_t i;
+	char *ret;
+
+	ret = dst;
+	for (i = 0; i < size; i++) {
+		*dst++ = *src;
+		// If strlen(src) < size, null-pad 'dst' out to 'size' chars
+		if (*src != '\0')
+			src++;
+	}
+	return ret;
+}
+
+size_t
+strlcpy(char *dst, const char *src, size_t size)
+{
+	char *dst_in;
+
+	dst_in = dst;
+	if (size > 0) {
+		while (--size > 0 && *src != '\0')
+			*dst++ = *src++;
+		*dst = '\0';
+	}
+	return dst - dst_in;
+}
+
+int
+strcmp(const char *p, const char *q)
+{
+	while (*p && *p == *q)
+		p++, q++;
+	return (int) ((unsigned char) *p - (unsigned char) *q);
+}
+
+int
+strncmp(const char *p, const char *q, size_t n)
+{
+	while (n > 0 && *p && *p == *q)
+		n--, p++, q++;
+	if (n == 0)
+		return 0;
+	else
+		return (int) ((unsigned char) *p - (unsigned char) *q);
+}
+
+// Return a pointer to the first occurrence of 'c' in 's',
+// or a null pointer if the string has no 'c'.
+char *
+strchr(const char *s, char c)
+{
+	for (; *s; s++)
+		if (*s == c)
+			return (char *) s;
+	return 0;
+}
+
+// Return a pointer to the first occurrence of 'c' in 's',
+// or a pointer to the string-ending null character if the string has no 'c'.
+char *
+strfind(const char *s, char c)
+{
+	for (; *s; s++)
+		if (*s == c)
+			break;
+	return (char *) s;
+}
+
+#if ASM
+void *
+memset(void *v, int c, size_t n)
+{
+	char *p;
+
+	if (n == 0)
+		return v;
+	if ((int)v%4 == 0 && n%4 == 0) {
+		c &= 0xFF;
+		c = (c<<24)|(c<<16)|(c<<8)|c;
+		asm volatile("cld; rep stosl\n"
+			:: "D" (v), "a" (c), "c" (n/4)
+			: "cc", "memory");
+	} else
+		asm volatile("cld; rep stosb\n"
+			:: "D" (v), "a" (c), "c" (n)
+			: "cc", "memory");
+	return v;
+}
+
+void *
+memmove(void *dst, const void *src, size_t n)
+{
+	const char *s;
+	char *d;
+
+	s = src;
+	d = dst;
+	if (s < d && s + n > d) {
+		s += n;
+		d += n;
+		if ((int)s%4 == 0 && (int)d%4 == 0 && n%4 == 0)
+			asm volatile("std; rep movsl\n"
+				:: "D" (d-4), "S" (s-4), "c" (n/4) : "cc", "memory");
+		else
+			asm volatile("std; rep movsb\n"
+				:: "D" (d-1), "S" (s-1), "c" (n) : "cc", "memory");
+		// Some versions of GCC rely on DF being clear
+		asm volatile("cld" ::: "cc");
+	} else {
+		if ((int)s%4 == 0 && (int)d%4 == 0 && n%4 == 0)
+			asm volatile("cld; rep movsl\n"
+				:: "D" (d), "S" (s), "c" (n/4) : "cc", "memory");
+		else
+			asm volatile("cld; rep movsb\n"
+				:: "D" (d), "S" (s), "c" (n) : "cc", "memory");
+	}
+	return dst;
+}
+
+#else
+
+void *
+memset(void *v, int c, size_t n)
+{
+	char *p;
+	int m;
+
+	p = v;
+	m = n;
+	while (--m >= 0)
+		*p++ = c;
+
+	return v;
+}
+
+void *
+memmove(void *dst, const void *src, size_t n)
+{
+	const char *s;
+	char *d;
+
+	s = src;
+	d = dst;
+	if (s < d && s + n > d) {
+		s += n;
+		d += n;
+		while (n-- > 0)
+			*--d = *--s;
+	} else
+		while (n-- > 0)
+			*d++ = *s++;
+
+	return dst;
+}
+#endif
+
+void *
+memcpy(void *dst, const void *src, size_t n)
+{
+	return memmove(dst, src, n);
+}
+
+int
+memcmp(const void *v1, const void *v2, size_t n)
+{
+	const uint8_t *s1 = (const uint8_t *) v1;
+	const uint8_t *s2 = (const uint8_t *) v2;
+
+	while (n-- > 0) {
+		if (*s1 != *s2)
+			return (int) *s1 - (int) *s2;
+		s1++, s2++;
+	}
+
+	return 0;
+}
+
+void *
+memfind(const void *s, int c, size_t n)
+{
+	const void *ends = (const char *) s + n;
+	for (; s < ends; s++)
+		if (*(const unsigned char *) s == (unsigned char) c)
+			break;
+	return (void *) s;
+}
+
+long
+strtol(const char *s, char **endptr, int base)
+{
+	int neg = 0;
+	long val = 0;
+
+	// gobble initial whitespace
+	while (*s == ' ' || *s == '\t')
+		s++;
+
+	// plus/minus sign
+	if (*s == '+')
+		s++;
+	else if (*s == '-')
+		s++, neg = 1;
+
+	// hex or octal base prefix
+	if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x'))
+		s += 2, base = 16;
+	else if (base == 0 && s[0] == '0')
+		s++, base = 8;
+	else if (base == 0)
+		base = 10;
+
+	// digits
+	while (1) {
+		int dig;
+
+		if (*s >= '0' && *s <= '9')
+			dig = *s - '0';
+		else if (*s >= 'a' && *s <= 'z')
+			dig = *s - 'a' + 10;
+		else if (*s >= 'A' && *s <= 'Z')
+			dig = *s - 'A' + 10;
+		else
+			break;
+		if (dig >= base)
+			break;
+		s++, val = (val * base) + dig;
+		// we don't properly detect overflow!
+	}
+
+	if (endptr)
+		*endptr = (char *) s;
+	return (neg ? -val : val);
+}
+
diff --git a/mergedep.pl b/mergedep.pl
new file mode 100644
index 0000000..1730d53
--- /dev/null
+++ b/mergedep.pl
@@ -0,0 +1,86 @@
+#!/usr/bin/perl
+# Copyright 2003 Bryan Ford
+# Distributed under the GNU General Public License.
+#
+# Usage: mergedep <main-depfile> [<new-depfiles> ...]
+#
+# This script merges the contents of all <new-depfiles> specified
+# on the command line into the single file <main-depfile>,
+# which may or may not previously exist.
+# Dependencies in the <new-depfiles> will override
+# any existing dependencies for the same targets in <main-depfile>.
+# The <new-depfiles> are deleted after <main-depfile> is updated.
+#
+# The <new-depfiles> are typically generated by GCC with the -MD option,
+# and the <main-depfile> is typically included from a Makefile,
+# as shown here for GNU 'make':
+#
+#	.deps: $(wildcard *.d)
+#		perl mergedep $@ $^
+#	-include .deps
+#
+# This script properly handles multiple dependencies per <new-depfile>,
+# including dependencies having no target,
+# so it is compatible with GCC3's -MP option.
+#
+
+sub readdeps {
+	my $filename = shift;
+
+	open(DEPFILE, $filename) or return 0;
+	while (<DEPFILE>) {
+		if (/([^:]*):([^\\:]*)([\\]?)$/) {
+			my $target = $1;
+			my $deplines = $2;
+			my $slash = $3;
+			while ($slash ne '') {
+				$_ = <DEPFILE>;
+				defined($_) or die
+					"Unterminated dependency in $filename";
+				/(^[ \t][^\\]*)([\\]?)$/ or die
+					"Bad continuation line in $filename";
+				$deplines = "$deplines\\\n$1";
+				$slash = $2;
+			}
+			#print "DEPENDENCY [[$target]]: [[$deplines]]\n";
+			$dephash{$target} = $deplines;
+		} elsif (/^[#]?[ \t]*$/) {
+			# ignore blank lines and comments
+		} else {
+			die "Bad dependency line in $filename: $_";
+		}
+	}
+	close DEPFILE;
+	return 1;
+}
+
+
+if ($#ARGV < 0) {
+	print "Usage: mergedep <main-depfile> [<new-depfiles> ..]\n";
+	exit(1);
+}
+
+%dephash = ();
+
+# Read the main dependency file
+$maindeps = $ARGV[0];
+readdeps($maindeps);
+
+# Read and merge in the new dependency files
+foreach $i (1 .. $#ARGV) {
+	readdeps($ARGV[$i]) or die "Can't open $ARGV[$i]";
+}
+
+# Update the main dependency file
+open(DEPFILE, ">$maindeps.tmp") or die "Can't open output file $maindeps.tmp";
+foreach $target (keys %dephash) {
+	print DEPFILE "$target:$dephash{$target}";
+}
+close DEPFILE;
+rename("$maindeps.tmp", "$maindeps") or die "Can't overwrite $maindeps";
+
+# Finally, delete the new dependency files
+foreach $i (1 .. $#ARGV) {
+	unlink($ARGV[$i]) or print "Error removing $ARGV[$i]\n";
+}
+
diff --git a/obj/.deps b/obj/.deps
new file mode 100644
index 0000000..1f6e344
--- /dev/null
+++ b/obj/.deps
@@ -0,0 +1,21 @@
+obj/kern/init.o: kern/init.c inc/stdio.h inc/stdarg.h inc/string.h \
+ inc/types.h inc/assert.h kern/monitor.h kern/console.h
+obj/kern/entry.o: kern/entry.S inc/mmu.h inc/memlayout.h
+obj/kern/readline.o: lib/readline.c inc/stdio.h inc/stdarg.h inc/error.h
+obj/boot/main.o: boot/main.c inc/x86.h inc/types.h inc/elf.h
+obj/kern/string.o: lib/string.c inc/string.h inc/types.h
+obj/kern/printfmt.o: lib/printfmt.c inc/types.h inc/stdio.h inc/stdarg.h \
+ inc/string.h inc/error.h
+obj/boot/boot.o: boot/boot.S inc/mmu.h
+obj/kern/console.o: kern/console.c inc/x86.h inc/types.h inc/memlayout.h \
+ inc/mmu.h inc/kbdreg.h inc/string.h inc/assert.h inc/stdio.h \
+ inc/stdarg.h kern/console.h
+obj/kern/printf.o: kern/printf.c inc/types.h inc/stdio.h inc/stdarg.h
+obj/kern/kdebug.o: kern/kdebug.c inc/stab.h inc/types.h inc/string.h \
+ inc/memlayout.h inc/mmu.h inc/assert.h inc/stdio.h inc/stdarg.h \
+ kern/kdebug.h
+obj/kern/monitor.o: kern/monitor.c inc/stdio.h inc/stdarg.h inc/string.h \
+ inc/types.h inc/memlayout.h inc/mmu.h inc/assert.h inc/x86.h \
+ kern/console.h kern/monitor.h kern/kdebug.h
+obj/kern/entrypgdir.o: kern/entrypgdir.c inc/mmu.h inc/types.h \
+ inc/memlayout.h
diff --git a/obj/.vars.INIT_CFLAGS b/obj/.vars.INIT_CFLAGS
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/obj/.vars.INIT_CFLAGS
@@ -0,0 +1 @@
+
diff --git a/obj/.vars.KERN_CFLAGS b/obj/.vars.KERN_CFLAGS
new file mode 100644
index 0000000..49b052d
--- /dev/null
+++ b/obj/.vars.KERN_CFLAGS
@@ -0,0 +1 @@
+   -O1 -fno-builtin -I. -MD -fno-omit-frame-pointer -std=gnu99 -static -Wall -Wno-format -Wno-unused -Werror -gstabs -m32 -fno-tree-ch -fno-pic -fno-pie -fno-stack-protector -DJOS_KERNEL -gstabs
diff --git a/obj/.vars.KERN_LDFLAGS b/obj/.vars.KERN_LDFLAGS
new file mode 100644
index 0000000..29bdd68
--- /dev/null
+++ b/obj/.vars.KERN_LDFLAGS
@@ -0,0 +1 @@
+-m elf_i386 -T kern/kernel.ld -nostdlib
diff --git a/obj/boot/boot b/obj/boot/boot
new file mode 100755
index 0000000..e76311a
Binary files /dev/null and b/obj/boot/boot differ
diff --git a/obj/boot/boot.asm b/obj/boot/boot.asm
new file mode 100644
index 0000000..f834530
--- /dev/null
+++ b/obj/boot/boot.asm
@@ -0,0 +1,325 @@
+
+obj/boot/boot.out:     file format elf32-i386
+
+
+Disassembly of section .text:
+
+00007c00 <start>:
+.set CR0_PE_ON,      0x1         # protected mode enable flag
+
+.globl start
+start:
+  .code16                     # Assemble for 16-bit mode
+  cli                         # Disable interrupts
+    7c00:	fa                   	cli    
+  cld                         # String operations increment
+    7c01:	fc                   	cld    
+
+  # Set up the important data segment registers (DS, ES, SS).
+  xorw    %ax,%ax             # Segment number zero
+    7c02:	31 c0                	xor    %eax,%eax
+  movw    %ax,%ds             # -> Data Segment
+    7c04:	8e d8                	mov    %eax,%ds
+  movw    %ax,%es             # -> Extra Segment
+    7c06:	8e c0                	mov    %eax,%es
+  movw    %ax,%ss             # -> Stack Segment
+    7c08:	8e d0                	mov    %eax,%ss
+
+00007c0a <seta20.1>:
+  # Enable A20:
+  #   For backwards compatibility with the earliest PCs, physical
+  #   address line 20 is tied low, so that addresses higher than
+  #   1MB wrap around to zero by default.  This code undoes this.
+seta20.1:
+  inb     $0x64,%al               # Wait for not busy
+    7c0a:	e4 64                	in     $0x64,%al
+  testb   $0x2,%al
+    7c0c:	a8 02                	test   $0x2,%al
+  jnz     seta20.1
+    7c0e:	75 fa                	jne    7c0a <seta20.1>
+
+  movb    $0xd1,%al               # 0xd1 -> port 0x64
+    7c10:	b0 d1                	mov    $0xd1,%al
+  outb    %al,$0x64
+    7c12:	e6 64                	out    %al,$0x64
+
+00007c14 <seta20.2>:
+
+seta20.2:
+  inb     $0x64,%al               # Wait for not busy
+    7c14:	e4 64                	in     $0x64,%al
+  testb   $0x2,%al
+    7c16:	a8 02                	test   $0x2,%al
+  jnz     seta20.2
+    7c18:	75 fa                	jne    7c14 <seta20.2>
+
+  movb    $0xdf,%al               # 0xdf -> port 0x60
+    7c1a:	b0 df                	mov    $0xdf,%al
+  outb    %al,$0x60
+    7c1c:	e6 60                	out    %al,$0x60
+
+  # Switch from real to protected mode, using a bootstrap GDT
+  # and segment translation that makes virtual addresses 
+  # identical to their physical addresses, so that the 
+  # effective memory map does not change during the switch.
+  lgdt    gdtdesc
+    7c1e:	0f 01 16             	lgdtl  (%esi)
+    7c21:	64 7c 0f             	fs jl  7c33 <protcseg+0x1>
+  movl    %cr0, %eax
+    7c24:	20 c0                	and    %al,%al
+  orl     $CR0_PE_ON, %eax
+    7c26:	66 83 c8 01          	or     $0x1,%ax
+  movl    %eax, %cr0
+    7c2a:	0f 22 c0             	mov    %eax,%cr0
+  
+  # Jump to next instruction, but in 32-bit code segment.
+  # Switches processor into 32-bit mode.
+  ljmp    $PROT_MODE_CSEG, $protcseg
+    7c2d:	ea                   	.byte 0xea
+    7c2e:	32 7c 08 00          	xor    0x0(%eax,%ecx,1),%bh
+
+00007c32 <protcseg>:
+
+  .code32                     # Assemble for 32-bit mode
+protcseg:
+  # Set up the protected-mode data segment registers
+  movw    $PROT_MODE_DSEG, %ax    # Our data segment selector
+    7c32:	66 b8 10 00          	mov    $0x10,%ax
+  movw    %ax, %ds                # -> DS: Data Segment
+    7c36:	8e d8                	mov    %eax,%ds
+  movw    %ax, %es                # -> ES: Extra Segment
+    7c38:	8e c0                	mov    %eax,%es
+  movw    %ax, %fs                # -> FS
+    7c3a:	8e e0                	mov    %eax,%fs
+  movw    %ax, %gs                # -> GS
+    7c3c:	8e e8                	mov    %eax,%gs
+  movw    %ax, %ss                # -> SS: Stack Segment
+    7c3e:	8e d0                	mov    %eax,%ss
+  
+  # Set up the stack pointer and call into C.
+  movl    $start, %esp
+    7c40:	bc 00 7c 00 00       	mov    $0x7c00,%esp
+  call bootmain
+    7c45:	e8 db 00 00 00       	call   7d25 <bootmain>
+
+00007c4a <spin>:
+
+  # If bootmain returns (it shouldn't), loop.
+spin:
+  jmp spin
+    7c4a:	eb fe                	jmp    7c4a <spin>
+
+00007c4c <gdt>:
+	...
+    7c54:	ff                   	(bad)  
+    7c55:	ff 00                	incl   (%eax)
+    7c57:	00 00                	add    %al,(%eax)
+    7c59:	9a cf 00 ff ff 00 00 	lcall  $0x0,$0xffff00cf
+    7c60:	00                   	.byte 0x0
+    7c61:	92                   	xchg   %eax,%edx
+    7c62:	cf                   	iret   
+	...
+
+00007c64 <gdtdesc>:
+    7c64:	17                   	pop    %ss
+    7c65:	00 4c 7c 00          	add    %cl,0x0(%esp,%edi,2)
+	...
+
+00007c6a <waitdisk>:
+	}
+}
+
+void
+waitdisk(void)
+{
+    7c6a:	f3 0f 1e fb          	endbr32 
+
+static inline uint8_t
+inb(int port)
+{
+	uint8_t data;
+	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
+    7c6e:	ba f7 01 00 00       	mov    $0x1f7,%edx
+    7c73:	ec                   	in     (%dx),%al
+	// wait for disk reaady
+	while ((inb(0x1F7) & 0xC0) != 0x40)
+    7c74:	83 e0 c0             	and    $0xffffffc0,%eax
+    7c77:	3c 40                	cmp    $0x40,%al
+    7c79:	75 f8                	jne    7c73 <waitdisk+0x9>
+		/* do nothing */;
+}
+    7c7b:	c3                   	ret    
+
+00007c7c <readsect>:
+
+void
+readsect(void *dst, uint32_t offset)
+{
+    7c7c:	f3 0f 1e fb          	endbr32 
+    7c80:	55                   	push   %ebp
+    7c81:	89 e5                	mov    %esp,%ebp
+    7c83:	57                   	push   %edi
+    7c84:	50                   	push   %eax
+    7c85:	8b 4d 0c             	mov    0xc(%ebp),%ecx
+	// wait for disk to be ready
+	waitdisk();
+    7c88:	e8 dd ff ff ff       	call   7c6a <waitdisk>
+}
+
+static inline void
+outb(int port, uint8_t data)
+{
+	asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
+    7c8d:	b0 01                	mov    $0x1,%al
+    7c8f:	ba f2 01 00 00       	mov    $0x1f2,%edx
+    7c94:	ee                   	out    %al,(%dx)
+    7c95:	ba f3 01 00 00       	mov    $0x1f3,%edx
+    7c9a:	89 c8                	mov    %ecx,%eax
+    7c9c:	ee                   	out    %al,(%dx)
+
+	outb(0x1F2, 1);		// count = 1
+	outb(0x1F3, offset);
+	outb(0x1F4, offset >> 8);
+    7c9d:	89 c8                	mov    %ecx,%eax
+    7c9f:	ba f4 01 00 00       	mov    $0x1f4,%edx
+    7ca4:	c1 e8 08             	shr    $0x8,%eax
+    7ca7:	ee                   	out    %al,(%dx)
+	outb(0x1F5, offset >> 16);
+    7ca8:	89 c8                	mov    %ecx,%eax
+    7caa:	ba f5 01 00 00       	mov    $0x1f5,%edx
+    7caf:	c1 e8 10             	shr    $0x10,%eax
+    7cb2:	ee                   	out    %al,(%dx)
+	outb(0x1F6, (offset >> 24) | 0xE0);
+    7cb3:	89 c8                	mov    %ecx,%eax
+    7cb5:	ba f6 01 00 00       	mov    $0x1f6,%edx
+    7cba:	c1 e8 18             	shr    $0x18,%eax
+    7cbd:	83 c8 e0             	or     $0xffffffe0,%eax
+    7cc0:	ee                   	out    %al,(%dx)
+    7cc1:	b0 20                	mov    $0x20,%al
+    7cc3:	ba f7 01 00 00       	mov    $0x1f7,%edx
+    7cc8:	ee                   	out    %al,(%dx)
+	outb(0x1F7, 0x20);	// cmd 0x20 - read sectors
+
+	// wait for disk to be ready
+	waitdisk();
+    7cc9:	e8 9c ff ff ff       	call   7c6a <waitdisk>
+	asm volatile("cld\n\trepne\n\tinsl"
+    7cce:	8b 7d 08             	mov    0x8(%ebp),%edi
+    7cd1:	b9 80 00 00 00       	mov    $0x80,%ecx
+    7cd6:	ba f0 01 00 00       	mov    $0x1f0,%edx
+    7cdb:	fc                   	cld    
+    7cdc:	f2 6d                	repnz insl (%dx),%es:(%edi)
+
+	// read a sector
+	insl(0x1F0, dst, SECTSIZE/4);
+}
+    7cde:	5a                   	pop    %edx
+    7cdf:	5f                   	pop    %edi
+    7ce0:	5d                   	pop    %ebp
+    7ce1:	c3                   	ret    
+
+00007ce2 <readseg>:
+{
+    7ce2:	f3 0f 1e fb          	endbr32 
+    7ce6:	55                   	push   %ebp
+    7ce7:	89 e5                	mov    %esp,%ebp
+    7ce9:	57                   	push   %edi
+    7cea:	56                   	push   %esi
+    7ceb:	53                   	push   %ebx
+    7cec:	83 ec 0c             	sub    $0xc,%esp
+	offset = (offset / SECTSIZE) + 1;
+    7cef:	8b 7d 10             	mov    0x10(%ebp),%edi
+{
+    7cf2:	8b 5d 08             	mov    0x8(%ebp),%ebx
+	end_pa = pa + count;
+    7cf5:	8b 75 0c             	mov    0xc(%ebp),%esi
+	offset = (offset / SECTSIZE) + 1;
+    7cf8:	c1 ef 09             	shr    $0x9,%edi
+	end_pa = pa + count;
+    7cfb:	01 de                	add    %ebx,%esi
+	offset = (offset / SECTSIZE) + 1;
+    7cfd:	47                   	inc    %edi
+	pa &= ~(SECTSIZE - 1);
+    7cfe:	81 e3 00 fe ff ff    	and    $0xfffffe00,%ebx
+	while (pa < end_pa) {
+    7d04:	39 f3                	cmp    %esi,%ebx
+    7d06:	73 15                	jae    7d1d <readseg+0x3b>
+		readsect((uint8_t*) pa, offset);
+    7d08:	50                   	push   %eax
+    7d09:	50                   	push   %eax
+    7d0a:	57                   	push   %edi
+		offset++;
+    7d0b:	47                   	inc    %edi
+		readsect((uint8_t*) pa, offset);
+    7d0c:	53                   	push   %ebx
+		pa += SECTSIZE;
+    7d0d:	81 c3 00 02 00 00    	add    $0x200,%ebx
+		readsect((uint8_t*) pa, offset);
+    7d13:	e8 64 ff ff ff       	call   7c7c <readsect>
+		offset++;
+    7d18:	83 c4 10             	add    $0x10,%esp
+    7d1b:	eb e7                	jmp    7d04 <readseg+0x22>
+}
+    7d1d:	8d 65 f4             	lea    -0xc(%ebp),%esp
+    7d20:	5b                   	pop    %ebx
+    7d21:	5e                   	pop    %esi
+    7d22:	5f                   	pop    %edi
+    7d23:	5d                   	pop    %ebp
+    7d24:	c3                   	ret    
+
+00007d25 <bootmain>:
+{
+    7d25:	f3 0f 1e fb          	endbr32 
+    7d29:	55                   	push   %ebp
+    7d2a:	89 e5                	mov    %esp,%ebp
+    7d2c:	56                   	push   %esi
+    7d2d:	53                   	push   %ebx
+	readseg((uint32_t) ELFHDR, SECTSIZE*8, 0);
+    7d2e:	52                   	push   %edx
+    7d2f:	6a 00                	push   $0x0
+    7d31:	68 00 10 00 00       	push   $0x1000
+    7d36:	68 00 00 01 00       	push   $0x10000
+    7d3b:	e8 a2 ff ff ff       	call   7ce2 <readseg>
+	if (ELFHDR->e_magic != ELF_MAGIC)
+    7d40:	83 c4 10             	add    $0x10,%esp
+    7d43:	81 3d 00 00 01 00 7f 	cmpl   $0x464c457f,0x10000
+    7d4a:	45 4c 46 
+    7d4d:	75 38                	jne    7d87 <bootmain+0x62>
+	ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
+    7d4f:	a1 1c 00 01 00       	mov    0x1001c,%eax
+	eph = ph + ELFHDR->e_phnum;
+    7d54:	0f b7 35 2c 00 01 00 	movzwl 0x1002c,%esi
+	ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
+    7d5b:	8d 98 00 00 01 00    	lea    0x10000(%eax),%ebx
+	eph = ph + ELFHDR->e_phnum;
+    7d61:	c1 e6 05             	shl    $0x5,%esi
+    7d64:	01 de                	add    %ebx,%esi
+	for (; ph < eph; ph++)
+    7d66:	39 f3                	cmp    %esi,%ebx
+    7d68:	73 17                	jae    7d81 <bootmain+0x5c>
+		readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
+    7d6a:	50                   	push   %eax
+	for (; ph < eph; ph++)
+    7d6b:	83 c3 20             	add    $0x20,%ebx
+		readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
+    7d6e:	ff 73 e4             	pushl  -0x1c(%ebx)
+    7d71:	ff 73 f4             	pushl  -0xc(%ebx)
+    7d74:	ff 73 ec             	pushl  -0x14(%ebx)
+    7d77:	e8 66 ff ff ff       	call   7ce2 <readseg>
+	for (; ph < eph; ph++)
+    7d7c:	83 c4 10             	add    $0x10,%esp
+    7d7f:	eb e5                	jmp    7d66 <bootmain+0x41>
+	((void (*)(void)) (ELFHDR->e_entry))();
+    7d81:	ff 15 18 00 01 00    	call   *0x10018
+}
+
+static inline void
+outw(int port, uint16_t data)
+{
+	asm volatile("outw %0,%w1" : : "a" (data), "d" (port));
+    7d87:	ba 00 8a 00 00       	mov    $0x8a00,%edx
+    7d8c:	b8 00 8a ff ff       	mov    $0xffff8a00,%eax
+    7d91:	66 ef                	out    %ax,(%dx)
+    7d93:	b8 00 8e ff ff       	mov    $0xffff8e00,%eax
+    7d98:	66 ef                	out    %ax,(%dx)
+    7d9a:	eb fe                	jmp    7d9a <bootmain+0x75>
diff --git a/obj/boot/boot.o b/obj/boot/boot.o
new file mode 100644
index 0000000..6c598b7
Binary files /dev/null and b/obj/boot/boot.o differ
diff --git a/obj/boot/boot.out b/obj/boot/boot.out
new file mode 100755
index 0000000..bcafbd5
Binary files /dev/null and b/obj/boot/boot.out differ
diff --git a/obj/boot/main.o b/obj/boot/main.o
new file mode 100644
index 0000000..1377c1a
Binary files /dev/null and b/obj/boot/main.o differ
diff --git a/obj/kern/console.o b/obj/kern/console.o
new file mode 100644
index 0000000..26c98a3
Binary files /dev/null and b/obj/kern/console.o differ
diff --git a/obj/kern/entry.o b/obj/kern/entry.o
new file mode 100644
index 0000000..228ec89
Binary files /dev/null and b/obj/kern/entry.o differ
diff --git a/obj/kern/entrypgdir.o b/obj/kern/entrypgdir.o
new file mode 100644
index 0000000..ee5a872
Binary files /dev/null and b/obj/kern/entrypgdir.o differ
diff --git a/obj/kern/init.o b/obj/kern/init.o
new file mode 100644
index 0000000..0320385
Binary files /dev/null and b/obj/kern/init.o differ
diff --git a/obj/kern/kdebug.o b/obj/kern/kdebug.o
new file mode 100644
index 0000000..9f79a45
Binary files /dev/null and b/obj/kern/kdebug.o differ
diff --git a/obj/kern/kernel b/obj/kern/kernel
new file mode 100755
index 0000000..c9a8cd9
Binary files /dev/null and b/obj/kern/kernel differ
diff --git a/obj/kern/kernel.asm b/obj/kern/kernel.asm
new file mode 100644
index 0000000..fc152ad
--- /dev/null
+++ b/obj/kern/kernel.asm
@@ -0,0 +1,3349 @@
+
+obj/kern/kernel:     file format elf32-i386
+
+
+Disassembly of section .text:
+
+f0100000 <_start+0xeffffff4>:
+.globl		_start
+_start = RELOC(entry)
+
+.globl entry
+entry:
+	movw	$0x1234,0x472			# warm boot
+f0100000:	02 b0 ad 1b 00 00    	add    0x1bad(%eax),%dh
+f0100006:	00 00                	add    %al,(%eax)
+f0100008:	fe 4f 52             	decb   0x52(%edi)
+f010000b:	e4                   	.byte 0xe4
+
+f010000c <entry>:
+f010000c:	66 c7 05 72 04 00 00 	movw   $0x1234,0x472
+f0100013:	34 12 
+	# sufficient until we set up our real page table in mem_init
+	# in lab 2.
+
+	# Load the physical address of entry_pgdir into cr3.  entry_pgdir
+	# is defined in entrypgdir.c.
+	movl	$(RELOC(entry_pgdir)), %eax
+f0100015:	b8 00 00 11 00       	mov    $0x110000,%eax
+	movl	%eax, %cr3
+f010001a:	0f 22 d8             	mov    %eax,%cr3
+	# Turn on paging.
+	movl	%cr0, %eax
+f010001d:	0f 20 c0             	mov    %cr0,%eax
+	orl	$(CR0_PE|CR0_PG|CR0_WP), %eax
+f0100020:	0d 01 00 01 80       	or     $0x80010001,%eax
+	movl	%eax, %cr0
+f0100025:	0f 22 c0             	mov    %eax,%cr0
+
+	# Now paging is enabled, but we're still running at a low EIP
+	# (why is this okay?).  Jump up above KERNBASE before entering
+	# C code.
+	mov	$relocated, %eax
+f0100028:	b8 2f 00 10 f0       	mov    $0xf010002f,%eax
+	jmp	*%eax
+f010002d:	ff e0                	jmp    *%eax
+
+f010002f <relocated>:
+relocated:
+
+	# Clear the frame pointer register (EBP)
+	# so that once we get into debugging C code,
+	# stack backtraces will be terminated properly.
+	movl	$0x0,%ebp			# nuke frame pointer
+f010002f:	bd 00 00 00 00       	mov    $0x0,%ebp
+
+	# Set the stack pointer
+	movl	$(bootstacktop),%esp
+f0100034:	bc 00 00 11 f0       	mov    $0xf0110000,%esp
+
+	# now to C code
+	call	i386_init
+f0100039:	e8 5a 00 00 00       	call   f0100098 <i386_init>
+
+f010003e <spin>:
+
+	# Should never get here, but in case we do, just spin.
+spin:	jmp	spin
+f010003e:	eb fe                	jmp    f010003e <spin>
+
+f0100040 <test_backtrace>:
+#include <kern/console.h>
+
+// Test the stack backtrace function (lab 1 only)
+void
+test_backtrace(int x)
+{
+f0100040:	f3 0f 1e fb          	endbr32 
+f0100044:	55                   	push   %ebp
+f0100045:	89 e5                	mov    %esp,%ebp
+f0100047:	53                   	push   %ebx
+f0100048:	83 ec 0c             	sub    $0xc,%esp
+f010004b:	8b 5d 08             	mov    0x8(%ebp),%ebx
+	cprintf("entering test_backtrace %d\n", x);
+f010004e:	53                   	push   %ebx
+f010004f:	68 a0 18 10 f0       	push   $0xf01018a0
+f0100054:	e8 ce 08 00 00       	call   f0100927 <cprintf>
+	if (x > 0)
+f0100059:	83 c4 10             	add    $0x10,%esp
+f010005c:	85 db                	test   %ebx,%ebx
+f010005e:	7e 25                	jle    f0100085 <test_backtrace+0x45>
+		test_backtrace(x-1);
+f0100060:	83 ec 0c             	sub    $0xc,%esp
+f0100063:	8d 43 ff             	lea    -0x1(%ebx),%eax
+f0100066:	50                   	push   %eax
+f0100067:	e8 d4 ff ff ff       	call   f0100040 <test_backtrace>
+f010006c:	83 c4 10             	add    $0x10,%esp
+	else
+		mon_backtrace(0, 0, 0);
+	cprintf("leaving test_backtrace %d\n", x);
+f010006f:	83 ec 08             	sub    $0x8,%esp
+f0100072:	53                   	push   %ebx
+f0100073:	68 bc 18 10 f0       	push   $0xf01018bc
+f0100078:	e8 aa 08 00 00       	call   f0100927 <cprintf>
+}
+f010007d:	83 c4 10             	add    $0x10,%esp
+f0100080:	8b 5d fc             	mov    -0x4(%ebp),%ebx
+f0100083:	c9                   	leave  
+f0100084:	c3                   	ret    
+		mon_backtrace(0, 0, 0);
+f0100085:	83 ec 04             	sub    $0x4,%esp
+f0100088:	6a 00                	push   $0x0
+f010008a:	6a 00                	push   $0x0
+f010008c:	6a 00                	push   $0x0
+f010008e:	e8 ff 06 00 00       	call   f0100792 <mon_backtrace>
+f0100093:	83 c4 10             	add    $0x10,%esp
+f0100096:	eb d7                	jmp    f010006f <test_backtrace+0x2f>
+
+f0100098 <i386_init>:
+
+void
+i386_init(void)
+{
+f0100098:	f3 0f 1e fb          	endbr32 
+f010009c:	55                   	push   %ebp
+f010009d:	89 e5                	mov    %esp,%ebp
+f010009f:	83 ec 0c             	sub    $0xc,%esp
+	extern char edata[], end[];
+
+	// Before doing anything else, complete the ELF loading process.
+	// Clear the uninitialized global data (BSS) section of our program.
+	// This ensures that all static/global variables start out zero.
+	memset(edata, 0, end - edata);
+f01000a2:	b8 40 29 11 f0       	mov    $0xf0112940,%eax
+f01000a7:	2d 00 23 11 f0       	sub    $0xf0112300,%eax
+f01000ac:	50                   	push   %eax
+f01000ad:	6a 00                	push   $0x0
+f01000af:	68 00 23 11 f0       	push   $0xf0112300
+f01000b4:	e8 62 13 00 00       	call   f010141b <memset>
+
+	// Initialize the console.
+	// Can't call cprintf until after we do this!
+	cons_init();
+f01000b9:	e8 af 04 00 00       	call   f010056d <cons_init>
+
+	cprintf("6828 decimal is %o octal!\n", 6828);
+f01000be:	83 c4 08             	add    $0x8,%esp
+f01000c1:	68 ac 1a 00 00       	push   $0x1aac
+f01000c6:	68 d7 18 10 f0       	push   $0xf01018d7
+f01000cb:	e8 57 08 00 00       	call   f0100927 <cprintf>
+
+	// Test the stack backtrace function (lab 1 only)
+	test_backtrace(5);
+f01000d0:	c7 04 24 05 00 00 00 	movl   $0x5,(%esp)
+f01000d7:	e8 64 ff ff ff       	call   f0100040 <test_backtrace>
+f01000dc:	83 c4 10             	add    $0x10,%esp
+
+	// Drop into the kernel monitor.
+	while (1)
+		monitor(NULL);
+f01000df:	83 ec 0c             	sub    $0xc,%esp
+f01000e2:	6a 00                	push   $0x0
+f01000e4:	e8 b3 06 00 00       	call   f010079c <monitor>
+f01000e9:	83 c4 10             	add    $0x10,%esp
+f01000ec:	eb f1                	jmp    f01000df <i386_init+0x47>
+
+f01000ee <_panic>:
+ * Panic is called on unresolvable fatal errors.
+ * It prints "panic: mesg", and then enters the kernel monitor.
+ */
+void
+_panic(const char *file, int line, const char *fmt,...)
+{
+f01000ee:	f3 0f 1e fb          	endbr32 
+f01000f2:	55                   	push   %ebp
+f01000f3:	89 e5                	mov    %esp,%ebp
+f01000f5:	56                   	push   %esi
+f01000f6:	53                   	push   %ebx
+f01000f7:	8b 75 10             	mov    0x10(%ebp),%esi
+	va_list ap;
+
+	if (panicstr)
+f01000fa:	83 3d 44 29 11 f0 00 	cmpl   $0x0,0xf0112944
+f0100101:	74 0f                	je     f0100112 <_panic+0x24>
+	va_end(ap);
+
+dead:
+	/* break into the kernel monitor */
+	while (1)
+		monitor(NULL);
+f0100103:	83 ec 0c             	sub    $0xc,%esp
+f0100106:	6a 00                	push   $0x0
+f0100108:	e8 8f 06 00 00       	call   f010079c <monitor>
+f010010d:	83 c4 10             	add    $0x10,%esp
+f0100110:	eb f1                	jmp    f0100103 <_panic+0x15>
+	panicstr = fmt;
+f0100112:	89 35 44 29 11 f0    	mov    %esi,0xf0112944
+	asm volatile("cli; cld");
+f0100118:	fa                   	cli    
+f0100119:	fc                   	cld    
+	va_start(ap, fmt);
+f010011a:	8d 5d 14             	lea    0x14(%ebp),%ebx
+	cprintf("kernel panic at %s:%d: ", file, line);
+f010011d:	83 ec 04             	sub    $0x4,%esp
+f0100120:	ff 75 0c             	pushl  0xc(%ebp)
+f0100123:	ff 75 08             	pushl  0x8(%ebp)
+f0100126:	68 f2 18 10 f0       	push   $0xf01018f2
+f010012b:	e8 f7 07 00 00       	call   f0100927 <cprintf>
+	vcprintf(fmt, ap);
+f0100130:	83 c4 08             	add    $0x8,%esp
+f0100133:	53                   	push   %ebx
+f0100134:	56                   	push   %esi
+f0100135:	e8 c3 07 00 00       	call   f01008fd <vcprintf>
+	cprintf("\n");
+f010013a:	c7 04 24 2e 19 10 f0 	movl   $0xf010192e,(%esp)
+f0100141:	e8 e1 07 00 00       	call   f0100927 <cprintf>
+f0100146:	83 c4 10             	add    $0x10,%esp
+f0100149:	eb b8                	jmp    f0100103 <_panic+0x15>
+
+f010014b <_warn>:
+}
+
+/* like panic, but don't */
+void
+_warn(const char *file, int line, const char *fmt,...)
+{
+f010014b:	f3 0f 1e fb          	endbr32 
+f010014f:	55                   	push   %ebp
+f0100150:	89 e5                	mov    %esp,%ebp
+f0100152:	53                   	push   %ebx
+f0100153:	83 ec 08             	sub    $0x8,%esp
+	va_list ap;
+
+	va_start(ap, fmt);
+f0100156:	8d 5d 14             	lea    0x14(%ebp),%ebx
+	cprintf("kernel warning at %s:%d: ", file, line);
+f0100159:	ff 75 0c             	pushl  0xc(%ebp)
+f010015c:	ff 75 08             	pushl  0x8(%ebp)
+f010015f:	68 0a 19 10 f0       	push   $0xf010190a
+f0100164:	e8 be 07 00 00       	call   f0100927 <cprintf>
+	vcprintf(fmt, ap);
+f0100169:	83 c4 08             	add    $0x8,%esp
+f010016c:	53                   	push   %ebx
+f010016d:	ff 75 10             	pushl  0x10(%ebp)
+f0100170:	e8 88 07 00 00       	call   f01008fd <vcprintf>
+	cprintf("\n");
+f0100175:	c7 04 24 2e 19 10 f0 	movl   $0xf010192e,(%esp)
+f010017c:	e8 a6 07 00 00       	call   f0100927 <cprintf>
+	va_end(ap);
+}
+f0100181:	83 c4 10             	add    $0x10,%esp
+f0100184:	8b 5d fc             	mov    -0x4(%ebp),%ebx
+f0100187:	c9                   	leave  
+f0100188:	c3                   	ret    
+
+f0100189 <serial_proc_data>:
+
+static bool serial_exists;
+
+static int
+serial_proc_data(void)
+{
+f0100189:	f3 0f 1e fb          	endbr32 
+
+static inline uint8_t
+inb(int port)
+{
+	uint8_t data;
+	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
+f010018d:	ba fd 03 00 00       	mov    $0x3fd,%edx
+f0100192:	ec                   	in     (%dx),%al
+	if (!(inb(COM1+COM_LSR) & COM_LSR_DATA))
+f0100193:	a8 01                	test   $0x1,%al
+f0100195:	74 0a                	je     f01001a1 <serial_proc_data+0x18>
+f0100197:	ba f8 03 00 00       	mov    $0x3f8,%edx
+f010019c:	ec                   	in     (%dx),%al
+		return -1;
+	return inb(COM1+COM_RX);
+f010019d:	0f b6 c0             	movzbl %al,%eax
+f01001a0:	c3                   	ret    
+		return -1;
+f01001a1:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
+}
+f01001a6:	c3                   	ret    
+
+f01001a7 <cons_intr>:
+
+// called by device interrupt routines to feed input characters
+// into the circular console input buffer.
+static void
+cons_intr(int (*proc)(void))
+{
+f01001a7:	55                   	push   %ebp
+f01001a8:	89 e5                	mov    %esp,%ebp
+f01001aa:	53                   	push   %ebx
+f01001ab:	83 ec 04             	sub    $0x4,%esp
+f01001ae:	89 c3                	mov    %eax,%ebx
+	int c;
+
+	while ((c = (*proc)()) != -1) {
+f01001b0:	ff d3                	call   *%ebx
+f01001b2:	83 f8 ff             	cmp    $0xffffffff,%eax
+f01001b5:	74 29                	je     f01001e0 <cons_intr+0x39>
+		if (c == 0)
+f01001b7:	85 c0                	test   %eax,%eax
+f01001b9:	74 f5                	je     f01001b0 <cons_intr+0x9>
+			continue;
+		cons.buf[cons.wpos++] = c;
+f01001bb:	8b 0d 24 25 11 f0    	mov    0xf0112524,%ecx
+f01001c1:	8d 51 01             	lea    0x1(%ecx),%edx
+f01001c4:	88 81 20 23 11 f0    	mov    %al,-0xfeedce0(%ecx)
+		if (cons.wpos == CONSBUFSIZE)
+f01001ca:	81 fa 00 02 00 00    	cmp    $0x200,%edx
+			cons.wpos = 0;
+f01001d0:	b8 00 00 00 00       	mov    $0x0,%eax
+f01001d5:	0f 44 d0             	cmove  %eax,%edx
+f01001d8:	89 15 24 25 11 f0    	mov    %edx,0xf0112524
+f01001de:	eb d0                	jmp    f01001b0 <cons_intr+0x9>
+	}
+}
+f01001e0:	83 c4 04             	add    $0x4,%esp
+f01001e3:	5b                   	pop    %ebx
+f01001e4:	5d                   	pop    %ebp
+f01001e5:	c3                   	ret    
+
+f01001e6 <kbd_proc_data>:
+{
+f01001e6:	f3 0f 1e fb          	endbr32 
+f01001ea:	55                   	push   %ebp
+f01001eb:	89 e5                	mov    %esp,%ebp
+f01001ed:	53                   	push   %ebx
+f01001ee:	83 ec 04             	sub    $0x4,%esp
+f01001f1:	ba 64 00 00 00       	mov    $0x64,%edx
+f01001f6:	ec                   	in     (%dx),%al
+	if ((stat & KBS_DIB) == 0)
+f01001f7:	a8 01                	test   $0x1,%al
+f01001f9:	0f 84 f2 00 00 00    	je     f01002f1 <kbd_proc_data+0x10b>
+	if (stat & KBS_TERR)
+f01001ff:	a8 20                	test   $0x20,%al
+f0100201:	0f 85 f1 00 00 00    	jne    f01002f8 <kbd_proc_data+0x112>
+f0100207:	ba 60 00 00 00       	mov    $0x60,%edx
+f010020c:	ec                   	in     (%dx),%al
+f010020d:	89 c2                	mov    %eax,%edx
+	if (data == 0xE0) {
+f010020f:	3c e0                	cmp    $0xe0,%al
+f0100211:	74 61                	je     f0100274 <kbd_proc_data+0x8e>
+	} else if (data & 0x80) {
+f0100213:	84 c0                	test   %al,%al
+f0100215:	78 70                	js     f0100287 <kbd_proc_data+0xa1>
+	} else if (shift & E0ESC) {
+f0100217:	8b 0d 00 23 11 f0    	mov    0xf0112300,%ecx
+f010021d:	f6 c1 40             	test   $0x40,%cl
+f0100220:	74 0e                	je     f0100230 <kbd_proc_data+0x4a>
+		data |= 0x80;
+f0100222:	83 c8 80             	or     $0xffffff80,%eax
+f0100225:	89 c2                	mov    %eax,%edx
+		shift &= ~E0ESC;
+f0100227:	83 e1 bf             	and    $0xffffffbf,%ecx
+f010022a:	89 0d 00 23 11 f0    	mov    %ecx,0xf0112300
+	shift |= shiftcode[data];
+f0100230:	0f b6 d2             	movzbl %dl,%edx
+f0100233:	0f b6 82 80 1a 10 f0 	movzbl -0xfefe580(%edx),%eax
+f010023a:	0b 05 00 23 11 f0    	or     0xf0112300,%eax
+	shift ^= togglecode[data];
+f0100240:	0f b6 8a 80 19 10 f0 	movzbl -0xfefe680(%edx),%ecx
+f0100247:	31 c8                	xor    %ecx,%eax
+f0100249:	a3 00 23 11 f0       	mov    %eax,0xf0112300
+	c = charcode[shift & (CTL | SHIFT)][data];
+f010024e:	89 c1                	mov    %eax,%ecx
+f0100250:	83 e1 03             	and    $0x3,%ecx
+f0100253:	8b 0c 8d 60 19 10 f0 	mov    -0xfefe6a0(,%ecx,4),%ecx
+f010025a:	0f b6 14 11          	movzbl (%ecx,%edx,1),%edx
+f010025e:	0f b6 da             	movzbl %dl,%ebx
+	if (shift & CAPSLOCK) {
+f0100261:	a8 08                	test   $0x8,%al
+f0100263:	74 61                	je     f01002c6 <kbd_proc_data+0xe0>
+		if ('a' <= c && c <= 'z')
+f0100265:	89 da                	mov    %ebx,%edx
+f0100267:	8d 4b 9f             	lea    -0x61(%ebx),%ecx
+f010026a:	83 f9 19             	cmp    $0x19,%ecx
+f010026d:	77 4b                	ja     f01002ba <kbd_proc_data+0xd4>
+			c += 'A' - 'a';
+f010026f:	83 eb 20             	sub    $0x20,%ebx
+f0100272:	eb 0c                	jmp    f0100280 <kbd_proc_data+0x9a>
+		shift |= E0ESC;
+f0100274:	83 0d 00 23 11 f0 40 	orl    $0x40,0xf0112300
+		return 0;
+f010027b:	bb 00 00 00 00       	mov    $0x0,%ebx
+}
+f0100280:	89 d8                	mov    %ebx,%eax
+f0100282:	8b 5d fc             	mov    -0x4(%ebp),%ebx
+f0100285:	c9                   	leave  
+f0100286:	c3                   	ret    
+		data = (shift & E0ESC ? data : data & 0x7F);
+f0100287:	8b 0d 00 23 11 f0    	mov    0xf0112300,%ecx
+f010028d:	89 cb                	mov    %ecx,%ebx
+f010028f:	83 e3 40             	and    $0x40,%ebx
+f0100292:	83 e0 7f             	and    $0x7f,%eax
+f0100295:	85 db                	test   %ebx,%ebx
+f0100297:	0f 44 d0             	cmove  %eax,%edx
+		shift &= ~(shiftcode[data] | E0ESC);
+f010029a:	0f b6 d2             	movzbl %dl,%edx
+f010029d:	0f b6 82 80 1a 10 f0 	movzbl -0xfefe580(%edx),%eax
+f01002a4:	83 c8 40             	or     $0x40,%eax
+f01002a7:	0f b6 c0             	movzbl %al,%eax
+f01002aa:	f7 d0                	not    %eax
+f01002ac:	21 c8                	and    %ecx,%eax
+f01002ae:	a3 00 23 11 f0       	mov    %eax,0xf0112300
+		return 0;
+f01002b3:	bb 00 00 00 00       	mov    $0x0,%ebx
+f01002b8:	eb c6                	jmp    f0100280 <kbd_proc_data+0x9a>
+		else if ('A' <= c && c <= 'Z')
+f01002ba:	83 ea 41             	sub    $0x41,%edx
+			c += 'a' - 'A';
+f01002bd:	8d 4b 20             	lea    0x20(%ebx),%ecx
+f01002c0:	83 fa 1a             	cmp    $0x1a,%edx
+f01002c3:	0f 42 d9             	cmovb  %ecx,%ebx
+	if (!(~shift & (CTL | ALT)) && c == KEY_DEL) {
+f01002c6:	f7 d0                	not    %eax
+f01002c8:	a8 06                	test   $0x6,%al
+f01002ca:	75 b4                	jne    f0100280 <kbd_proc_data+0x9a>
+f01002cc:	81 fb e9 00 00 00    	cmp    $0xe9,%ebx
+f01002d2:	75 ac                	jne    f0100280 <kbd_proc_data+0x9a>
+		cprintf("Rebooting!\n");
+f01002d4:	83 ec 0c             	sub    $0xc,%esp
+f01002d7:	68 24 19 10 f0       	push   $0xf0101924
+f01002dc:	e8 46 06 00 00       	call   f0100927 <cprintf>
+}
+
+static inline void
+outb(int port, uint8_t data)
+{
+	asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
+f01002e1:	b8 03 00 00 00       	mov    $0x3,%eax
+f01002e6:	ba 92 00 00 00       	mov    $0x92,%edx
+f01002eb:	ee                   	out    %al,(%dx)
+}
+f01002ec:	83 c4 10             	add    $0x10,%esp
+f01002ef:	eb 8f                	jmp    f0100280 <kbd_proc_data+0x9a>
+		return -1;
+f01002f1:	bb ff ff ff ff       	mov    $0xffffffff,%ebx
+f01002f6:	eb 88                	jmp    f0100280 <kbd_proc_data+0x9a>
+		return -1;
+f01002f8:	bb ff ff ff ff       	mov    $0xffffffff,%ebx
+f01002fd:	eb 81                	jmp    f0100280 <kbd_proc_data+0x9a>
+
+f01002ff <cons_putc>:
+}
+
+// output a character to the console
+static void
+cons_putc(int c)
+{
+f01002ff:	55                   	push   %ebp
+f0100300:	89 e5                	mov    %esp,%ebp
+f0100302:	57                   	push   %edi
+f0100303:	56                   	push   %esi
+f0100304:	53                   	push   %ebx
+f0100305:	83 ec 1c             	sub    $0x1c,%esp
+f0100308:	89 c1                	mov    %eax,%ecx
+	for (i = 0;
+f010030a:	be 00 00 00 00       	mov    $0x0,%esi
+	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
+f010030f:	bf fd 03 00 00       	mov    $0x3fd,%edi
+f0100314:	bb 84 00 00 00       	mov    $0x84,%ebx
+f0100319:	89 fa                	mov    %edi,%edx
+f010031b:	ec                   	in     (%dx),%al
+	     !(inb(COM1 + COM_LSR) & COM_LSR_TXRDY) && i < 12800;
+f010031c:	a8 20                	test   $0x20,%al
+f010031e:	75 13                	jne    f0100333 <cons_putc+0x34>
+f0100320:	81 fe ff 31 00 00    	cmp    $0x31ff,%esi
+f0100326:	7f 0b                	jg     f0100333 <cons_putc+0x34>
+f0100328:	89 da                	mov    %ebx,%edx
+f010032a:	ec                   	in     (%dx),%al
+f010032b:	ec                   	in     (%dx),%al
+f010032c:	ec                   	in     (%dx),%al
+f010032d:	ec                   	in     (%dx),%al
+	     i++)
+f010032e:	83 c6 01             	add    $0x1,%esi
+f0100331:	eb e6                	jmp    f0100319 <cons_putc+0x1a>
+	outb(COM1 + COM_TX, c);
+f0100333:	88 4d e7             	mov    %cl,-0x19(%ebp)
+	asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
+f0100336:	ba f8 03 00 00       	mov    $0x3f8,%edx
+f010033b:	89 c8                	mov    %ecx,%eax
+f010033d:	ee                   	out    %al,(%dx)
+	for (i = 0; !(inb(0x378+1) & 0x80) && i < 12800; i++)
+f010033e:	be 00 00 00 00       	mov    $0x0,%esi
+	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
+f0100343:	bf 79 03 00 00       	mov    $0x379,%edi
+f0100348:	bb 84 00 00 00       	mov    $0x84,%ebx
+f010034d:	89 fa                	mov    %edi,%edx
+f010034f:	ec                   	in     (%dx),%al
+f0100350:	81 fe ff 31 00 00    	cmp    $0x31ff,%esi
+f0100356:	7f 0f                	jg     f0100367 <cons_putc+0x68>
+f0100358:	84 c0                	test   %al,%al
+f010035a:	78 0b                	js     f0100367 <cons_putc+0x68>
+f010035c:	89 da                	mov    %ebx,%edx
+f010035e:	ec                   	in     (%dx),%al
+f010035f:	ec                   	in     (%dx),%al
+f0100360:	ec                   	in     (%dx),%al
+f0100361:	ec                   	in     (%dx),%al
+f0100362:	83 c6 01             	add    $0x1,%esi
+f0100365:	eb e6                	jmp    f010034d <cons_putc+0x4e>
+	asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
+f0100367:	ba 78 03 00 00       	mov    $0x378,%edx
+f010036c:	0f b6 45 e7          	movzbl -0x19(%ebp),%eax
+f0100370:	ee                   	out    %al,(%dx)
+f0100371:	ba 7a 03 00 00       	mov    $0x37a,%edx
+f0100376:	b8 0d 00 00 00       	mov    $0xd,%eax
+f010037b:	ee                   	out    %al,(%dx)
+f010037c:	b8 08 00 00 00       	mov    $0x8,%eax
+f0100381:	ee                   	out    %al,(%dx)
+		c |= 0x0700;
+f0100382:	89 c8                	mov    %ecx,%eax
+f0100384:	80 cc 07             	or     $0x7,%ah
+f0100387:	f7 c1 00 ff ff ff    	test   $0xffffff00,%ecx
+f010038d:	0f 44 c8             	cmove  %eax,%ecx
+	switch (c & 0xff) {
+f0100390:	0f b6 c1             	movzbl %cl,%eax
+f0100393:	80 f9 0a             	cmp    $0xa,%cl
+f0100396:	0f 84 dd 00 00 00    	je     f0100479 <cons_putc+0x17a>
+f010039c:	83 f8 0a             	cmp    $0xa,%eax
+f010039f:	7f 46                	jg     f01003e7 <cons_putc+0xe8>
+f01003a1:	83 f8 08             	cmp    $0x8,%eax
+f01003a4:	0f 84 a7 00 00 00    	je     f0100451 <cons_putc+0x152>
+f01003aa:	83 f8 09             	cmp    $0x9,%eax
+f01003ad:	0f 85 d3 00 00 00    	jne    f0100486 <cons_putc+0x187>
+		cons_putc(' ');
+f01003b3:	b8 20 00 00 00       	mov    $0x20,%eax
+f01003b8:	e8 42 ff ff ff       	call   f01002ff <cons_putc>
+		cons_putc(' ');
+f01003bd:	b8 20 00 00 00       	mov    $0x20,%eax
+f01003c2:	e8 38 ff ff ff       	call   f01002ff <cons_putc>
+		cons_putc(' ');
+f01003c7:	b8 20 00 00 00       	mov    $0x20,%eax
+f01003cc:	e8 2e ff ff ff       	call   f01002ff <cons_putc>
+		cons_putc(' ');
+f01003d1:	b8 20 00 00 00       	mov    $0x20,%eax
+f01003d6:	e8 24 ff ff ff       	call   f01002ff <cons_putc>
+		cons_putc(' ');
+f01003db:	b8 20 00 00 00       	mov    $0x20,%eax
+f01003e0:	e8 1a ff ff ff       	call   f01002ff <cons_putc>
+		break;
+f01003e5:	eb 25                	jmp    f010040c <cons_putc+0x10d>
+	switch (c & 0xff) {
+f01003e7:	83 f8 0d             	cmp    $0xd,%eax
+f01003ea:	0f 85 96 00 00 00    	jne    f0100486 <cons_putc+0x187>
+		crt_pos -= (crt_pos % CRT_COLS);
+f01003f0:	0f b7 05 28 25 11 f0 	movzwl 0xf0112528,%eax
+f01003f7:	69 c0 cd cc 00 00    	imul   $0xcccd,%eax,%eax
+f01003fd:	c1 e8 16             	shr    $0x16,%eax
+f0100400:	8d 04 80             	lea    (%eax,%eax,4),%eax
+f0100403:	c1 e0 04             	shl    $0x4,%eax
+f0100406:	66 a3 28 25 11 f0    	mov    %ax,0xf0112528
+	if (crt_pos >= CRT_SIZE) {
+f010040c:	66 81 3d 28 25 11 f0 	cmpw   $0x7cf,0xf0112528
+f0100413:	cf 07 
+f0100415:	0f 87 8e 00 00 00    	ja     f01004a9 <cons_putc+0x1aa>
+	outb(addr_6845, 14);
+f010041b:	8b 0d 30 25 11 f0    	mov    0xf0112530,%ecx
+f0100421:	b8 0e 00 00 00       	mov    $0xe,%eax
+f0100426:	89 ca                	mov    %ecx,%edx
+f0100428:	ee                   	out    %al,(%dx)
+	outb(addr_6845 + 1, crt_pos >> 8);
+f0100429:	0f b7 1d 28 25 11 f0 	movzwl 0xf0112528,%ebx
+f0100430:	8d 71 01             	lea    0x1(%ecx),%esi
+f0100433:	89 d8                	mov    %ebx,%eax
+f0100435:	66 c1 e8 08          	shr    $0x8,%ax
+f0100439:	89 f2                	mov    %esi,%edx
+f010043b:	ee                   	out    %al,(%dx)
+f010043c:	b8 0f 00 00 00       	mov    $0xf,%eax
+f0100441:	89 ca                	mov    %ecx,%edx
+f0100443:	ee                   	out    %al,(%dx)
+f0100444:	89 d8                	mov    %ebx,%eax
+f0100446:	89 f2                	mov    %esi,%edx
+f0100448:	ee                   	out    %al,(%dx)
+	serial_putc(c);
+	lpt_putc(c);
+	cga_putc(c);
+}
+f0100449:	8d 65 f4             	lea    -0xc(%ebp),%esp
+f010044c:	5b                   	pop    %ebx
+f010044d:	5e                   	pop    %esi
+f010044e:	5f                   	pop    %edi
+f010044f:	5d                   	pop    %ebp
+f0100450:	c3                   	ret    
+		if (crt_pos > 0) {
+f0100451:	0f b7 05 28 25 11 f0 	movzwl 0xf0112528,%eax
+f0100458:	66 85 c0             	test   %ax,%ax
+f010045b:	74 be                	je     f010041b <cons_putc+0x11c>
+			crt_pos--;
+f010045d:	83 e8 01             	sub    $0x1,%eax
+f0100460:	66 a3 28 25 11 f0    	mov    %ax,0xf0112528
+			crt_buf[crt_pos] = (c & ~0xff) | ' ';
+f0100466:	0f b7 d0             	movzwl %ax,%edx
+f0100469:	b1 00                	mov    $0x0,%cl
+f010046b:	83 c9 20             	or     $0x20,%ecx
+f010046e:	a1 2c 25 11 f0       	mov    0xf011252c,%eax
+f0100473:	66 89 0c 50          	mov    %cx,(%eax,%edx,2)
+f0100477:	eb 93                	jmp    f010040c <cons_putc+0x10d>
+		crt_pos += CRT_COLS;
+f0100479:	66 83 05 28 25 11 f0 	addw   $0x50,0xf0112528
+f0100480:	50 
+f0100481:	e9 6a ff ff ff       	jmp    f01003f0 <cons_putc+0xf1>
+		crt_buf[crt_pos++] = c;		/* write the character */
+f0100486:	0f b7 05 28 25 11 f0 	movzwl 0xf0112528,%eax
+f010048d:	8d 50 01             	lea    0x1(%eax),%edx
+f0100490:	66 89 15 28 25 11 f0 	mov    %dx,0xf0112528
+f0100497:	0f b7 c0             	movzwl %ax,%eax
+f010049a:	8b 15 2c 25 11 f0    	mov    0xf011252c,%edx
+f01004a0:	66 89 0c 42          	mov    %cx,(%edx,%eax,2)
+		break;
+f01004a4:	e9 63 ff ff ff       	jmp    f010040c <cons_putc+0x10d>
+		memmove(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
+f01004a9:	a1 2c 25 11 f0       	mov    0xf011252c,%eax
+f01004ae:	83 ec 04             	sub    $0x4,%esp
+f01004b1:	68 00 0f 00 00       	push   $0xf00
+f01004b6:	8d 90 a0 00 00 00    	lea    0xa0(%eax),%edx
+f01004bc:	52                   	push   %edx
+f01004bd:	50                   	push   %eax
+f01004be:	e8 a4 0f 00 00       	call   f0101467 <memmove>
+			crt_buf[i] = 0x0700 | ' ';
+f01004c3:	8b 15 2c 25 11 f0    	mov    0xf011252c,%edx
+f01004c9:	8d 82 00 0f 00 00    	lea    0xf00(%edx),%eax
+f01004cf:	81 c2 a0 0f 00 00    	add    $0xfa0,%edx
+f01004d5:	83 c4 10             	add    $0x10,%esp
+f01004d8:	66 c7 00 20 07       	movw   $0x720,(%eax)
+f01004dd:	83 c0 02             	add    $0x2,%eax
+		for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i++)
+f01004e0:	39 d0                	cmp    %edx,%eax
+f01004e2:	75 f4                	jne    f01004d8 <cons_putc+0x1d9>
+		crt_pos -= CRT_COLS;
+f01004e4:	66 83 2d 28 25 11 f0 	subw   $0x50,0xf0112528
+f01004eb:	50 
+f01004ec:	e9 2a ff ff ff       	jmp    f010041b <cons_putc+0x11c>
+
+f01004f1 <serial_intr>:
+{
+f01004f1:	f3 0f 1e fb          	endbr32 
+	if (serial_exists)
+f01004f5:	80 3d 34 25 11 f0 00 	cmpb   $0x0,0xf0112534
+f01004fc:	75 01                	jne    f01004ff <serial_intr+0xe>
+f01004fe:	c3                   	ret    
+{
+f01004ff:	55                   	push   %ebp
+f0100500:	89 e5                	mov    %esp,%ebp
+f0100502:	83 ec 08             	sub    $0x8,%esp
+		cons_intr(serial_proc_data);
+f0100505:	b8 89 01 10 f0       	mov    $0xf0100189,%eax
+f010050a:	e8 98 fc ff ff       	call   f01001a7 <cons_intr>
+}
+f010050f:	c9                   	leave  
+f0100510:	c3                   	ret    
+
+f0100511 <kbd_intr>:
+{
+f0100511:	f3 0f 1e fb          	endbr32 
+f0100515:	55                   	push   %ebp
+f0100516:	89 e5                	mov    %esp,%ebp
+f0100518:	83 ec 08             	sub    $0x8,%esp
+	cons_intr(kbd_proc_data);
+f010051b:	b8 e6 01 10 f0       	mov    $0xf01001e6,%eax
+f0100520:	e8 82 fc ff ff       	call   f01001a7 <cons_intr>
+}
+f0100525:	c9                   	leave  
+f0100526:	c3                   	ret    
+
+f0100527 <cons_getc>:
+{
+f0100527:	f3 0f 1e fb          	endbr32 
+f010052b:	55                   	push   %ebp
+f010052c:	89 e5                	mov    %esp,%ebp
+f010052e:	83 ec 08             	sub    $0x8,%esp
+	serial_intr();
+f0100531:	e8 bb ff ff ff       	call   f01004f1 <serial_intr>
+	kbd_intr();
+f0100536:	e8 d6 ff ff ff       	call   f0100511 <kbd_intr>
+	if (cons.rpos != cons.wpos) {
+f010053b:	a1 20 25 11 f0       	mov    0xf0112520,%eax
+	return 0;
+f0100540:	ba 00 00 00 00       	mov    $0x0,%edx
+	if (cons.rpos != cons.wpos) {
+f0100545:	3b 05 24 25 11 f0    	cmp    0xf0112524,%eax
+f010054b:	74 1c                	je     f0100569 <cons_getc+0x42>
+		c = cons.buf[cons.rpos++];
+f010054d:	8d 48 01             	lea    0x1(%eax),%ecx
+f0100550:	0f b6 90 20 23 11 f0 	movzbl -0xfeedce0(%eax),%edx
+			cons.rpos = 0;
+f0100557:	3d ff 01 00 00       	cmp    $0x1ff,%eax
+f010055c:	b8 00 00 00 00       	mov    $0x0,%eax
+f0100561:	0f 45 c1             	cmovne %ecx,%eax
+f0100564:	a3 20 25 11 f0       	mov    %eax,0xf0112520
+}
+f0100569:	89 d0                	mov    %edx,%eax
+f010056b:	c9                   	leave  
+f010056c:	c3                   	ret    
+
+f010056d <cons_init>:
+
+// initialize the console devices
+void
+cons_init(void)
+{
+f010056d:	f3 0f 1e fb          	endbr32 
+f0100571:	55                   	push   %ebp
+f0100572:	89 e5                	mov    %esp,%ebp
+f0100574:	57                   	push   %edi
+f0100575:	56                   	push   %esi
+f0100576:	53                   	push   %ebx
+f0100577:	83 ec 0c             	sub    $0xc,%esp
+	was = *cp;
+f010057a:	0f b7 15 00 80 0b f0 	movzwl 0xf00b8000,%edx
+	*cp = (uint16_t) 0xA55A;
+f0100581:	66 c7 05 00 80 0b f0 	movw   $0xa55a,0xf00b8000
+f0100588:	5a a5 
+	if (*cp != 0xA55A) {
+f010058a:	0f b7 05 00 80 0b f0 	movzwl 0xf00b8000,%eax
+f0100591:	66 3d 5a a5          	cmp    $0xa55a,%ax
+f0100595:	0f 84 b7 00 00 00    	je     f0100652 <cons_init+0xe5>
+		addr_6845 = MONO_BASE;
+f010059b:	c7 05 30 25 11 f0 b4 	movl   $0x3b4,0xf0112530
+f01005a2:	03 00 00 
+		cp = (uint16_t*) (KERNBASE + MONO_BUF);
+f01005a5:	be 00 00 0b f0       	mov    $0xf00b0000,%esi
+	outb(addr_6845, 14);
+f01005aa:	8b 3d 30 25 11 f0    	mov    0xf0112530,%edi
+f01005b0:	b8 0e 00 00 00       	mov    $0xe,%eax
+f01005b5:	89 fa                	mov    %edi,%edx
+f01005b7:	ee                   	out    %al,(%dx)
+	pos = inb(addr_6845 + 1) << 8;
+f01005b8:	8d 4f 01             	lea    0x1(%edi),%ecx
+	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
+f01005bb:	89 ca                	mov    %ecx,%edx
+f01005bd:	ec                   	in     (%dx),%al
+f01005be:	0f b6 c0             	movzbl %al,%eax
+f01005c1:	c1 e0 08             	shl    $0x8,%eax
+f01005c4:	89 c3                	mov    %eax,%ebx
+	asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
+f01005c6:	b8 0f 00 00 00       	mov    $0xf,%eax
+f01005cb:	89 fa                	mov    %edi,%edx
+f01005cd:	ee                   	out    %al,(%dx)
+	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
+f01005ce:	89 ca                	mov    %ecx,%edx
+f01005d0:	ec                   	in     (%dx),%al
+	crt_buf = (uint16_t*) cp;
+f01005d1:	89 35 2c 25 11 f0    	mov    %esi,0xf011252c
+	pos |= inb(addr_6845 + 1);
+f01005d7:	0f b6 c0             	movzbl %al,%eax
+f01005da:	09 d8                	or     %ebx,%eax
+	crt_pos = pos;
+f01005dc:	66 a3 28 25 11 f0    	mov    %ax,0xf0112528
+	asm volatile("outb %0,%w1" : : "a" (data), "d" (port));
+f01005e2:	bb 00 00 00 00       	mov    $0x0,%ebx
+f01005e7:	b9 fa 03 00 00       	mov    $0x3fa,%ecx
+f01005ec:	89 d8                	mov    %ebx,%eax
+f01005ee:	89 ca                	mov    %ecx,%edx
+f01005f0:	ee                   	out    %al,(%dx)
+f01005f1:	bf fb 03 00 00       	mov    $0x3fb,%edi
+f01005f6:	b8 80 ff ff ff       	mov    $0xffffff80,%eax
+f01005fb:	89 fa                	mov    %edi,%edx
+f01005fd:	ee                   	out    %al,(%dx)
+f01005fe:	b8 0c 00 00 00       	mov    $0xc,%eax
+f0100603:	ba f8 03 00 00       	mov    $0x3f8,%edx
+f0100608:	ee                   	out    %al,(%dx)
+f0100609:	be f9 03 00 00       	mov    $0x3f9,%esi
+f010060e:	89 d8                	mov    %ebx,%eax
+f0100610:	89 f2                	mov    %esi,%edx
+f0100612:	ee                   	out    %al,(%dx)
+f0100613:	b8 03 00 00 00       	mov    $0x3,%eax
+f0100618:	89 fa                	mov    %edi,%edx
+f010061a:	ee                   	out    %al,(%dx)
+f010061b:	ba fc 03 00 00       	mov    $0x3fc,%edx
+f0100620:	89 d8                	mov    %ebx,%eax
+f0100622:	ee                   	out    %al,(%dx)
+f0100623:	b8 01 00 00 00       	mov    $0x1,%eax
+f0100628:	89 f2                	mov    %esi,%edx
+f010062a:	ee                   	out    %al,(%dx)
+	asm volatile("inb %w1,%0" : "=a" (data) : "d" (port));
+f010062b:	ba fd 03 00 00       	mov    $0x3fd,%edx
+f0100630:	ec                   	in     (%dx),%al
+f0100631:	89 c3                	mov    %eax,%ebx
+	serial_exists = (inb(COM1+COM_LSR) != 0xFF);
+f0100633:	3c ff                	cmp    $0xff,%al
+f0100635:	0f 95 05 34 25 11 f0 	setne  0xf0112534
+f010063c:	89 ca                	mov    %ecx,%edx
+f010063e:	ec                   	in     (%dx),%al
+f010063f:	ba f8 03 00 00       	mov    $0x3f8,%edx
+f0100644:	ec                   	in     (%dx),%al
+	cga_init();
+	kbd_init();
+	serial_init();
+
+	if (!serial_exists)
+f0100645:	80 fb ff             	cmp    $0xff,%bl
+f0100648:	74 23                	je     f010066d <cons_init+0x100>
+		cprintf("Serial port does not exist!\n");
+}
+f010064a:	8d 65 f4             	lea    -0xc(%ebp),%esp
+f010064d:	5b                   	pop    %ebx
+f010064e:	5e                   	pop    %esi
+f010064f:	5f                   	pop    %edi
+f0100650:	5d                   	pop    %ebp
+f0100651:	c3                   	ret    
+		*cp = was;
+f0100652:	66 89 15 00 80 0b f0 	mov    %dx,0xf00b8000
+		addr_6845 = CGA_BASE;
+f0100659:	c7 05 30 25 11 f0 d4 	movl   $0x3d4,0xf0112530
+f0100660:	03 00 00 
+	cp = (uint16_t*) (KERNBASE + CGA_BUF);
+f0100663:	be 00 80 0b f0       	mov    $0xf00b8000,%esi
+f0100668:	e9 3d ff ff ff       	jmp    f01005aa <cons_init+0x3d>
+		cprintf("Serial port does not exist!\n");
+f010066d:	83 ec 0c             	sub    $0xc,%esp
+f0100670:	68 30 19 10 f0       	push   $0xf0101930
+f0100675:	e8 ad 02 00 00       	call   f0100927 <cprintf>
+f010067a:	83 c4 10             	add    $0x10,%esp
+}
+f010067d:	eb cb                	jmp    f010064a <cons_init+0xdd>
+
+f010067f <cputchar>:
+
+// `High'-level console I/O.  Used by readline and cprintf.
+
+void
+cputchar(int c)
+{
+f010067f:	f3 0f 1e fb          	endbr32 
+f0100683:	55                   	push   %ebp
+f0100684:	89 e5                	mov    %esp,%ebp
+f0100686:	83 ec 08             	sub    $0x8,%esp
+	cons_putc(c);
+f0100689:	8b 45 08             	mov    0x8(%ebp),%eax
+f010068c:	e8 6e fc ff ff       	call   f01002ff <cons_putc>
+}
+f0100691:	c9                   	leave  
+f0100692:	c3                   	ret    
+
+f0100693 <getchar>:
+
+int
+getchar(void)
+{
+f0100693:	f3 0f 1e fb          	endbr32 
+f0100697:	55                   	push   %ebp
+f0100698:	89 e5                	mov    %esp,%ebp
+f010069a:	83 ec 08             	sub    $0x8,%esp
+	int c;
+
+	while ((c = cons_getc()) == 0)
+f010069d:	e8 85 fe ff ff       	call   f0100527 <cons_getc>
+f01006a2:	85 c0                	test   %eax,%eax
+f01006a4:	74 f7                	je     f010069d <getchar+0xa>
+		/* do nothing */;
+	return c;
+}
+f01006a6:	c9                   	leave  
+f01006a7:	c3                   	ret    
+
+f01006a8 <iscons>:
+
+int
+iscons(int fdnum)
+{
+f01006a8:	f3 0f 1e fb          	endbr32 
+	// used by readline
+	return 1;
+}
+f01006ac:	b8 01 00 00 00       	mov    $0x1,%eax
+f01006b1:	c3                   	ret    
+
+f01006b2 <mon_help>:
+
+/***** Implementations of basic kernel monitor commands *****/
+
+int
+mon_help(int argc, char **argv, struct Trapframe *tf)
+{
+f01006b2:	f3 0f 1e fb          	endbr32 
+f01006b6:	55                   	push   %ebp
+f01006b7:	89 e5                	mov    %esp,%ebp
+f01006b9:	83 ec 0c             	sub    $0xc,%esp
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(commands); i++)
+		cprintf("%s - %s\n", commands[i].name, commands[i].desc);
+f01006bc:	68 80 1b 10 f0       	push   $0xf0101b80
+f01006c1:	68 9e 1b 10 f0       	push   $0xf0101b9e
+f01006c6:	68 a3 1b 10 f0       	push   $0xf0101ba3
+f01006cb:	e8 57 02 00 00       	call   f0100927 <cprintf>
+f01006d0:	83 c4 0c             	add    $0xc,%esp
+f01006d3:	68 0c 1c 10 f0       	push   $0xf0101c0c
+f01006d8:	68 ac 1b 10 f0       	push   $0xf0101bac
+f01006dd:	68 a3 1b 10 f0       	push   $0xf0101ba3
+f01006e2:	e8 40 02 00 00       	call   f0100927 <cprintf>
+	return 0;
+}
+f01006e7:	b8 00 00 00 00       	mov    $0x0,%eax
+f01006ec:	c9                   	leave  
+f01006ed:	c3                   	ret    
+
+f01006ee <mon_kerninfo>:
+
+int
+mon_kerninfo(int argc, char **argv, struct Trapframe *tf)
+{
+f01006ee:	f3 0f 1e fb          	endbr32 
+f01006f2:	55                   	push   %ebp
+f01006f3:	89 e5                	mov    %esp,%ebp
+f01006f5:	83 ec 14             	sub    $0x14,%esp
+	extern char _start[], entry[], etext[], edata[], end[];
+
+	cprintf("Special kernel symbols:\n");
+f01006f8:	68 b5 1b 10 f0       	push   $0xf0101bb5
+f01006fd:	e8 25 02 00 00       	call   f0100927 <cprintf>
+	cprintf("  _start                  %08x (phys)\n", _start);
+f0100702:	83 c4 08             	add    $0x8,%esp
+f0100705:	68 0c 00 10 00       	push   $0x10000c
+f010070a:	68 34 1c 10 f0       	push   $0xf0101c34
+f010070f:	e8 13 02 00 00       	call   f0100927 <cprintf>
+	cprintf("  entry  %08x (virt)  %08x (phys)\n", entry, entry - KERNBASE);
+f0100714:	83 c4 0c             	add    $0xc,%esp
+f0100717:	68 0c 00 10 00       	push   $0x10000c
+f010071c:	68 0c 00 10 f0       	push   $0xf010000c
+f0100721:	68 5c 1c 10 f0       	push   $0xf0101c5c
+f0100726:	e8 fc 01 00 00       	call   f0100927 <cprintf>
+	cprintf("  etext  %08x (virt)  %08x (phys)\n", etext, etext - KERNBASE);
+f010072b:	83 c4 0c             	add    $0xc,%esp
+f010072e:	68 8d 18 10 00       	push   $0x10188d
+f0100733:	68 8d 18 10 f0       	push   $0xf010188d
+f0100738:	68 80 1c 10 f0       	push   $0xf0101c80
+f010073d:	e8 e5 01 00 00       	call   f0100927 <cprintf>
+	cprintf("  edata  %08x (virt)  %08x (phys)\n", edata, edata - KERNBASE);
+f0100742:	83 c4 0c             	add    $0xc,%esp
+f0100745:	68 00 23 11 00       	push   $0x112300
+f010074a:	68 00 23 11 f0       	push   $0xf0112300
+f010074f:	68 a4 1c 10 f0       	push   $0xf0101ca4
+f0100754:	e8 ce 01 00 00       	call   f0100927 <cprintf>
+	cprintf("  end    %08x (virt)  %08x (phys)\n", end, end - KERNBASE);
+f0100759:	83 c4 0c             	add    $0xc,%esp
+f010075c:	68 40 29 11 00       	push   $0x112940
+f0100761:	68 40 29 11 f0       	push   $0xf0112940
+f0100766:	68 c8 1c 10 f0       	push   $0xf0101cc8
+f010076b:	e8 b7 01 00 00       	call   f0100927 <cprintf>
+	cprintf("Kernel executable memory footprint: %dKB\n",
+f0100770:	83 c4 08             	add    $0x8,%esp
+		ROUNDUP(end - entry, 1024) / 1024);
+f0100773:	b8 40 29 11 f0       	mov    $0xf0112940,%eax
+f0100778:	2d 0d fc 0f f0       	sub    $0xf00ffc0d,%eax
+	cprintf("Kernel executable memory footprint: %dKB\n",
+f010077d:	c1 f8 0a             	sar    $0xa,%eax
+f0100780:	50                   	push   %eax
+f0100781:	68 ec 1c 10 f0       	push   $0xf0101cec
+f0100786:	e8 9c 01 00 00       	call   f0100927 <cprintf>
+	return 0;
+}
+f010078b:	b8 00 00 00 00       	mov    $0x0,%eax
+f0100790:	c9                   	leave  
+f0100791:	c3                   	ret    
+
+f0100792 <mon_backtrace>:
+
+int
+mon_backtrace(int argc, char **argv, struct Trapframe *tf)
+{
+f0100792:	f3 0f 1e fb          	endbr32 
+	// Your code here.
+	return 0;
+}
+f0100796:	b8 00 00 00 00       	mov    $0x0,%eax
+f010079b:	c3                   	ret    
+
+f010079c <monitor>:
+	return 0;
+}
+
+void
+monitor(struct Trapframe *tf)
+{
+f010079c:	f3 0f 1e fb          	endbr32 
+f01007a0:	55                   	push   %ebp
+f01007a1:	89 e5                	mov    %esp,%ebp
+f01007a3:	57                   	push   %edi
+f01007a4:	56                   	push   %esi
+f01007a5:	53                   	push   %ebx
+f01007a6:	83 ec 58             	sub    $0x58,%esp
+	char *buf;
+
+	cprintf("Welcome to the JOS kernel monitor!\n");
+f01007a9:	68 18 1d 10 f0       	push   $0xf0101d18
+f01007ae:	e8 74 01 00 00       	call   f0100927 <cprintf>
+	cprintf("Type 'help' for a list of commands.\n");
+f01007b3:	c7 04 24 3c 1d 10 f0 	movl   $0xf0101d3c,(%esp)
+f01007ba:	e8 68 01 00 00       	call   f0100927 <cprintf>
+f01007bf:	83 c4 10             	add    $0x10,%esp
+f01007c2:	e9 cf 00 00 00       	jmp    f0100896 <monitor+0xfa>
+		while (*buf && strchr(WHITESPACE, *buf))
+f01007c7:	83 ec 08             	sub    $0x8,%esp
+f01007ca:	0f be c0             	movsbl %al,%eax
+f01007cd:	50                   	push   %eax
+f01007ce:	68 d2 1b 10 f0       	push   $0xf0101bd2
+f01007d3:	e8 fe 0b 00 00       	call   f01013d6 <strchr>
+f01007d8:	83 c4 10             	add    $0x10,%esp
+f01007db:	85 c0                	test   %eax,%eax
+f01007dd:	74 6c                	je     f010084b <monitor+0xaf>
+			*buf++ = 0;
+f01007df:	c6 03 00             	movb   $0x0,(%ebx)
+f01007e2:	89 f7                	mov    %esi,%edi
+f01007e4:	8d 5b 01             	lea    0x1(%ebx),%ebx
+f01007e7:	89 fe                	mov    %edi,%esi
+		while (*buf && strchr(WHITESPACE, *buf))
+f01007e9:	0f b6 03             	movzbl (%ebx),%eax
+f01007ec:	84 c0                	test   %al,%al
+f01007ee:	75 d7                	jne    f01007c7 <monitor+0x2b>
+	argv[argc] = 0;
+f01007f0:	c7 44 b5 a8 00 00 00 	movl   $0x0,-0x58(%ebp,%esi,4)
+f01007f7:	00 
+	if (argc == 0)
+f01007f8:	85 f6                	test   %esi,%esi
+f01007fa:	0f 84 96 00 00 00    	je     f0100896 <monitor+0xfa>
+		if (strcmp(argv[0], commands[i].name) == 0)
+f0100800:	83 ec 08             	sub    $0x8,%esp
+f0100803:	68 9e 1b 10 f0       	push   $0xf0101b9e
+f0100808:	ff 75 a8             	pushl  -0x58(%ebp)
+f010080b:	e8 60 0b 00 00       	call   f0101370 <strcmp>
+f0100810:	83 c4 10             	add    $0x10,%esp
+f0100813:	85 c0                	test   %eax,%eax
+f0100815:	0f 84 a7 00 00 00    	je     f01008c2 <monitor+0x126>
+f010081b:	83 ec 08             	sub    $0x8,%esp
+f010081e:	68 ac 1b 10 f0       	push   $0xf0101bac
+f0100823:	ff 75 a8             	pushl  -0x58(%ebp)
+f0100826:	e8 45 0b 00 00       	call   f0101370 <strcmp>
+f010082b:	83 c4 10             	add    $0x10,%esp
+f010082e:	85 c0                	test   %eax,%eax
+f0100830:	0f 84 87 00 00 00    	je     f01008bd <monitor+0x121>
+	cprintf("Unknown command '%s'\n", argv[0]);
+f0100836:	83 ec 08             	sub    $0x8,%esp
+f0100839:	ff 75 a8             	pushl  -0x58(%ebp)
+f010083c:	68 f4 1b 10 f0       	push   $0xf0101bf4
+f0100841:	e8 e1 00 00 00       	call   f0100927 <cprintf>
+	return 0;
+f0100846:	83 c4 10             	add    $0x10,%esp
+f0100849:	eb 4b                	jmp    f0100896 <monitor+0xfa>
+		if (*buf == 0)
+f010084b:	80 3b 00             	cmpb   $0x0,(%ebx)
+f010084e:	74 a0                	je     f01007f0 <monitor+0x54>
+		if (argc == MAXARGS-1) {
+f0100850:	83 fe 0f             	cmp    $0xf,%esi
+f0100853:	74 2f                	je     f0100884 <monitor+0xe8>
+		argv[argc++] = buf;
+f0100855:	8d 7e 01             	lea    0x1(%esi),%edi
+f0100858:	89 5c b5 a8          	mov    %ebx,-0x58(%ebp,%esi,4)
+		while (*buf && !strchr(WHITESPACE, *buf))
+f010085c:	0f b6 03             	movzbl (%ebx),%eax
+f010085f:	84 c0                	test   %al,%al
+f0100861:	74 84                	je     f01007e7 <monitor+0x4b>
+f0100863:	83 ec 08             	sub    $0x8,%esp
+f0100866:	0f be c0             	movsbl %al,%eax
+f0100869:	50                   	push   %eax
+f010086a:	68 d2 1b 10 f0       	push   $0xf0101bd2
+f010086f:	e8 62 0b 00 00       	call   f01013d6 <strchr>
+f0100874:	83 c4 10             	add    $0x10,%esp
+f0100877:	85 c0                	test   %eax,%eax
+f0100879:	0f 85 68 ff ff ff    	jne    f01007e7 <monitor+0x4b>
+			buf++;
+f010087f:	83 c3 01             	add    $0x1,%ebx
+f0100882:	eb d8                	jmp    f010085c <monitor+0xc0>
+			cprintf("Too many arguments (max %d)\n", MAXARGS);
+f0100884:	83 ec 08             	sub    $0x8,%esp
+f0100887:	6a 10                	push   $0x10
+f0100889:	68 d7 1b 10 f0       	push   $0xf0101bd7
+f010088e:	e8 94 00 00 00       	call   f0100927 <cprintf>
+			return 0;
+f0100893:	83 c4 10             	add    $0x10,%esp
+
+
+	while (1) {
+		buf = readline("K> ");
+f0100896:	83 ec 0c             	sub    $0xc,%esp
+f0100899:	68 ce 1b 10 f0       	push   $0xf0101bce
+f010089e:	e8 e5 08 00 00       	call   f0101188 <readline>
+f01008a3:	89 c3                	mov    %eax,%ebx
+		if (buf != NULL)
+f01008a5:	83 c4 10             	add    $0x10,%esp
+f01008a8:	85 c0                	test   %eax,%eax
+f01008aa:	74 ea                	je     f0100896 <monitor+0xfa>
+	argv[argc] = 0;
+f01008ac:	c7 45 a8 00 00 00 00 	movl   $0x0,-0x58(%ebp)
+	argc = 0;
+f01008b3:	be 00 00 00 00       	mov    $0x0,%esi
+f01008b8:	e9 2c ff ff ff       	jmp    f01007e9 <monitor+0x4d>
+	for (i = 0; i < ARRAY_SIZE(commands); i++) {
+f01008bd:	b8 01 00 00 00       	mov    $0x1,%eax
+			return commands[i].func(argc, argv, tf);
+f01008c2:	83 ec 04             	sub    $0x4,%esp
+f01008c5:	8d 04 40             	lea    (%eax,%eax,2),%eax
+f01008c8:	ff 75 08             	pushl  0x8(%ebp)
+f01008cb:	8d 55 a8             	lea    -0x58(%ebp),%edx
+f01008ce:	52                   	push   %edx
+f01008cf:	56                   	push   %esi
+f01008d0:	ff 14 85 6c 1d 10 f0 	call   *-0xfefe294(,%eax,4)
+			if (runcmd(buf, tf) < 0)
+f01008d7:	83 c4 10             	add    $0x10,%esp
+f01008da:	85 c0                	test   %eax,%eax
+f01008dc:	79 b8                	jns    f0100896 <monitor+0xfa>
+				break;
+	}
+}
+f01008de:	8d 65 f4             	lea    -0xc(%ebp),%esp
+f01008e1:	5b                   	pop    %ebx
+f01008e2:	5e                   	pop    %esi
+f01008e3:	5f                   	pop    %edi
+f01008e4:	5d                   	pop    %ebp
+f01008e5:	c3                   	ret    
+
+f01008e6 <putch>:
+#include <inc/stdarg.h>
+
+
+static void
+putch(int ch, int *cnt)
+{
+f01008e6:	f3 0f 1e fb          	endbr32 
+f01008ea:	55                   	push   %ebp
+f01008eb:	89 e5                	mov    %esp,%ebp
+f01008ed:	83 ec 14             	sub    $0x14,%esp
+	cputchar(ch);
+f01008f0:	ff 75 08             	pushl  0x8(%ebp)
+f01008f3:	e8 87 fd ff ff       	call   f010067f <cputchar>
+	*cnt++;
+}
+f01008f8:	83 c4 10             	add    $0x10,%esp
+f01008fb:	c9                   	leave  
+f01008fc:	c3                   	ret    
+
+f01008fd <vcprintf>:
+
+int
+vcprintf(const char *fmt, va_list ap)
+{
+f01008fd:	f3 0f 1e fb          	endbr32 
+f0100901:	55                   	push   %ebp
+f0100902:	89 e5                	mov    %esp,%ebp
+f0100904:	83 ec 18             	sub    $0x18,%esp
+	int cnt = 0;
+f0100907:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
+
+	vprintfmt((void*)putch, &cnt, fmt, ap);
+f010090e:	ff 75 0c             	pushl  0xc(%ebp)
+f0100911:	ff 75 08             	pushl  0x8(%ebp)
+f0100914:	8d 45 f4             	lea    -0xc(%ebp),%eax
+f0100917:	50                   	push   %eax
+f0100918:	68 e6 08 10 f0       	push   $0xf01008e6
+f010091d:	e8 d3 03 00 00       	call   f0100cf5 <vprintfmt>
+	return cnt;
+}
+f0100922:	8b 45 f4             	mov    -0xc(%ebp),%eax
+f0100925:	c9                   	leave  
+f0100926:	c3                   	ret    
+
+f0100927 <cprintf>:
+
+int
+cprintf(const char *fmt, ...)
+{
+f0100927:	f3 0f 1e fb          	endbr32 
+f010092b:	55                   	push   %ebp
+f010092c:	89 e5                	mov    %esp,%ebp
+f010092e:	83 ec 10             	sub    $0x10,%esp
+	va_list ap;
+	int cnt;
+
+	va_start(ap, fmt);
+f0100931:	8d 45 0c             	lea    0xc(%ebp),%eax
+	cnt = vcprintf(fmt, ap);
+f0100934:	50                   	push   %eax
+f0100935:	ff 75 08             	pushl  0x8(%ebp)
+f0100938:	e8 c0 ff ff ff       	call   f01008fd <vcprintf>
+	va_end(ap);
+
+	return cnt;
+}
+f010093d:	c9                   	leave  
+f010093e:	c3                   	ret    
+
+f010093f <stab_binsearch>:
+//	will exit setting left = 118, right = 554.
+//
+static void
+stab_binsearch(const struct Stab *stabs, int *region_left, int *region_right,
+	       int type, uintptr_t addr)
+{
+f010093f:	55                   	push   %ebp
+f0100940:	89 e5                	mov    %esp,%ebp
+f0100942:	57                   	push   %edi
+f0100943:	56                   	push   %esi
+f0100944:	53                   	push   %ebx
+f0100945:	83 ec 14             	sub    $0x14,%esp
+f0100948:	89 45 ec             	mov    %eax,-0x14(%ebp)
+f010094b:	89 55 e4             	mov    %edx,-0x1c(%ebp)
+f010094e:	89 4d e0             	mov    %ecx,-0x20(%ebp)
+f0100951:	8b 75 08             	mov    0x8(%ebp),%esi
+	int l = *region_left, r = *region_right, any_matches = 0;
+f0100954:	8b 1a                	mov    (%edx),%ebx
+f0100956:	8b 01                	mov    (%ecx),%eax
+f0100958:	89 45 f0             	mov    %eax,-0x10(%ebp)
+f010095b:	c7 45 e8 00 00 00 00 	movl   $0x0,-0x18(%ebp)
+
+	while (l <= r) {
+f0100962:	eb 23                	jmp    f0100987 <stab_binsearch+0x48>
+
+		// search for earliest stab with right type
+		while (m >= l && stabs[m].n_type != type)
+			m--;
+		if (m < l) {	// no match in [l, m]
+			l = true_m + 1;
+f0100964:	8d 5f 01             	lea    0x1(%edi),%ebx
+			continue;
+f0100967:	eb 1e                	jmp    f0100987 <stab_binsearch+0x48>
+		}
+
+		// actual binary search
+		any_matches = 1;
+		if (stabs[m].n_value < addr) {
+f0100969:	8d 14 40             	lea    (%eax,%eax,2),%edx
+f010096c:	8b 4d ec             	mov    -0x14(%ebp),%ecx
+f010096f:	8b 54 91 08          	mov    0x8(%ecx,%edx,4),%edx
+f0100973:	3b 55 0c             	cmp    0xc(%ebp),%edx
+f0100976:	73 46                	jae    f01009be <stab_binsearch+0x7f>
+			*region_left = m;
+f0100978:	8b 5d e4             	mov    -0x1c(%ebp),%ebx
+f010097b:	89 03                	mov    %eax,(%ebx)
+			l = true_m + 1;
+f010097d:	8d 5f 01             	lea    0x1(%edi),%ebx
+		any_matches = 1;
+f0100980:	c7 45 e8 01 00 00 00 	movl   $0x1,-0x18(%ebp)
+	while (l <= r) {
+f0100987:	3b 5d f0             	cmp    -0x10(%ebp),%ebx
+f010098a:	7f 5f                	jg     f01009eb <stab_binsearch+0xac>
+		int true_m = (l + r) / 2, m = true_m;
+f010098c:	8b 45 f0             	mov    -0x10(%ebp),%eax
+f010098f:	8d 14 03             	lea    (%ebx,%eax,1),%edx
+f0100992:	89 d0                	mov    %edx,%eax
+f0100994:	c1 e8 1f             	shr    $0x1f,%eax
+f0100997:	01 d0                	add    %edx,%eax
+f0100999:	89 c7                	mov    %eax,%edi
+f010099b:	d1 ff                	sar    %edi
+f010099d:	83 e0 fe             	and    $0xfffffffe,%eax
+f01009a0:	01 f8                	add    %edi,%eax
+f01009a2:	8b 4d ec             	mov    -0x14(%ebp),%ecx
+f01009a5:	8d 54 81 04          	lea    0x4(%ecx,%eax,4),%edx
+f01009a9:	89 f8                	mov    %edi,%eax
+		while (m >= l && stabs[m].n_type != type)
+f01009ab:	39 c3                	cmp    %eax,%ebx
+f01009ad:	7f b5                	jg     f0100964 <stab_binsearch+0x25>
+f01009af:	0f b6 0a             	movzbl (%edx),%ecx
+f01009b2:	83 ea 0c             	sub    $0xc,%edx
+f01009b5:	39 f1                	cmp    %esi,%ecx
+f01009b7:	74 b0                	je     f0100969 <stab_binsearch+0x2a>
+			m--;
+f01009b9:	83 e8 01             	sub    $0x1,%eax
+f01009bc:	eb ed                	jmp    f01009ab <stab_binsearch+0x6c>
+		} else if (stabs[m].n_value > addr) {
+f01009be:	3b 55 0c             	cmp    0xc(%ebp),%edx
+f01009c1:	76 14                	jbe    f01009d7 <stab_binsearch+0x98>
+			*region_right = m - 1;
+f01009c3:	83 e8 01             	sub    $0x1,%eax
+f01009c6:	89 45 f0             	mov    %eax,-0x10(%ebp)
+f01009c9:	8b 7d e0             	mov    -0x20(%ebp),%edi
+f01009cc:	89 07                	mov    %eax,(%edi)
+		any_matches = 1;
+f01009ce:	c7 45 e8 01 00 00 00 	movl   $0x1,-0x18(%ebp)
+f01009d5:	eb b0                	jmp    f0100987 <stab_binsearch+0x48>
+			r = m - 1;
+		} else {
+			// exact match for 'addr', but continue loop to find
+			// *region_right
+			*region_left = m;
+f01009d7:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+f01009da:	89 07                	mov    %eax,(%edi)
+			l = m;
+			addr++;
+f01009dc:	83 45 0c 01          	addl   $0x1,0xc(%ebp)
+f01009e0:	89 c3                	mov    %eax,%ebx
+		any_matches = 1;
+f01009e2:	c7 45 e8 01 00 00 00 	movl   $0x1,-0x18(%ebp)
+f01009e9:	eb 9c                	jmp    f0100987 <stab_binsearch+0x48>
+		}
+	}
+
+	if (!any_matches)
+f01009eb:	83 7d e8 00          	cmpl   $0x0,-0x18(%ebp)
+f01009ef:	75 15                	jne    f0100a06 <stab_binsearch+0xc7>
+		*region_right = *region_left - 1;
+f01009f1:	8b 45 e4             	mov    -0x1c(%ebp),%eax
+f01009f4:	8b 00                	mov    (%eax),%eax
+f01009f6:	83 e8 01             	sub    $0x1,%eax
+f01009f9:	8b 7d e0             	mov    -0x20(%ebp),%edi
+f01009fc:	89 07                	mov    %eax,(%edi)
+		     l > *region_left && stabs[l].n_type != type;
+		     l--)
+			/* do nothing */;
+		*region_left = l;
+	}
+}
+f01009fe:	83 c4 14             	add    $0x14,%esp
+f0100a01:	5b                   	pop    %ebx
+f0100a02:	5e                   	pop    %esi
+f0100a03:	5f                   	pop    %edi
+f0100a04:	5d                   	pop    %ebp
+f0100a05:	c3                   	ret    
+		for (l = *region_right;
+f0100a06:	8b 45 e0             	mov    -0x20(%ebp),%eax
+f0100a09:	8b 00                	mov    (%eax),%eax
+		     l > *region_left && stabs[l].n_type != type;
+f0100a0b:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+f0100a0e:	8b 0f                	mov    (%edi),%ecx
+f0100a10:	8d 14 40             	lea    (%eax,%eax,2),%edx
+f0100a13:	8b 7d ec             	mov    -0x14(%ebp),%edi
+f0100a16:	8d 54 97 04          	lea    0x4(%edi,%edx,4),%edx
+		for (l = *region_right;
+f0100a1a:	eb 03                	jmp    f0100a1f <stab_binsearch+0xe0>
+		     l--)
+f0100a1c:	83 e8 01             	sub    $0x1,%eax
+		for (l = *region_right;
+f0100a1f:	39 c1                	cmp    %eax,%ecx
+f0100a21:	7d 0a                	jge    f0100a2d <stab_binsearch+0xee>
+		     l > *region_left && stabs[l].n_type != type;
+f0100a23:	0f b6 1a             	movzbl (%edx),%ebx
+f0100a26:	83 ea 0c             	sub    $0xc,%edx
+f0100a29:	39 f3                	cmp    %esi,%ebx
+f0100a2b:	75 ef                	jne    f0100a1c <stab_binsearch+0xdd>
+		*region_left = l;
+f0100a2d:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+f0100a30:	89 07                	mov    %eax,(%edi)
+}
+f0100a32:	eb ca                	jmp    f01009fe <stab_binsearch+0xbf>
+
+f0100a34 <debuginfo_eip>:
+//	negative if not.  But even if it returns negative it has stored some
+//	information into '*info'.
+//
+int
+debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info)
+{
+f0100a34:	f3 0f 1e fb          	endbr32 
+f0100a38:	55                   	push   %ebp
+f0100a39:	89 e5                	mov    %esp,%ebp
+f0100a3b:	57                   	push   %edi
+f0100a3c:	56                   	push   %esi
+f0100a3d:	53                   	push   %ebx
+f0100a3e:	83 ec 1c             	sub    $0x1c,%esp
+f0100a41:	8b 7d 08             	mov    0x8(%ebp),%edi
+f0100a44:	8b 75 0c             	mov    0xc(%ebp),%esi
+	const struct Stab *stabs, *stab_end;
+	const char *stabstr, *stabstr_end;
+	int lfile, rfile, lfun, rfun, lline, rline;
+
+	// Initialize *info
+	info->eip_file = "<unknown>";
+f0100a47:	c7 06 7c 1d 10 f0    	movl   $0xf0101d7c,(%esi)
+	info->eip_line = 0;
+f0100a4d:	c7 46 04 00 00 00 00 	movl   $0x0,0x4(%esi)
+	info->eip_fn_name = "<unknown>";
+f0100a54:	c7 46 08 7c 1d 10 f0 	movl   $0xf0101d7c,0x8(%esi)
+	info->eip_fn_namelen = 9;
+f0100a5b:	c7 46 0c 09 00 00 00 	movl   $0x9,0xc(%esi)
+	info->eip_fn_addr = addr;
+f0100a62:	89 7e 10             	mov    %edi,0x10(%esi)
+	info->eip_fn_narg = 0;
+f0100a65:	c7 46 14 00 00 00 00 	movl   $0x0,0x14(%esi)
+
+	// Find the relevant set of stabs
+	if (addr >= ULIM) {
+f0100a6c:	81 ff ff ff 7f ef    	cmp    $0xef7fffff,%edi
+f0100a72:	0f 86 db 00 00 00    	jbe    f0100b53 <debuginfo_eip+0x11f>
+		// Can't search for user-level addresses yet!
+  	        panic("User address");
+	}
+
+	// String table validity checks
+	if (stabstr_end <= stabstr || stabstr_end[-1] != 0)
+f0100a78:	b8 d7 7b 10 f0       	mov    $0xf0107bd7,%eax
+f0100a7d:	3d 2d 62 10 f0       	cmp    $0xf010622d,%eax
+f0100a82:	0f 86 5e 01 00 00    	jbe    f0100be6 <debuginfo_eip+0x1b2>
+f0100a88:	80 3d d6 7b 10 f0 00 	cmpb   $0x0,0xf0107bd6
+f0100a8f:	0f 85 58 01 00 00    	jne    f0100bed <debuginfo_eip+0x1b9>
+	// 'eip'.  First, we find the basic source file containing 'eip'.
+	// Then, we look in that source file for the function.  Then we look
+	// for the line number.
+
+	// Search the entire set of stabs for the source file (type N_SO).
+	lfile = 0;
+f0100a95:	c7 45 e4 00 00 00 00 	movl   $0x0,-0x1c(%ebp)
+	rfile = (stab_end - stabs) - 1;
+f0100a9c:	b8 2c 62 10 f0       	mov    $0xf010622c,%eax
+f0100aa1:	2d b4 1f 10 f0       	sub    $0xf0101fb4,%eax
+f0100aa6:	c1 f8 02             	sar    $0x2,%eax
+f0100aa9:	69 c0 ab aa aa aa    	imul   $0xaaaaaaab,%eax,%eax
+f0100aaf:	83 e8 01             	sub    $0x1,%eax
+f0100ab2:	89 45 e0             	mov    %eax,-0x20(%ebp)
+	stab_binsearch(stabs, &lfile, &rfile, N_SO, addr);
+f0100ab5:	83 ec 08             	sub    $0x8,%esp
+f0100ab8:	57                   	push   %edi
+f0100ab9:	6a 64                	push   $0x64
+f0100abb:	8d 4d e0             	lea    -0x20(%ebp),%ecx
+f0100abe:	8d 55 e4             	lea    -0x1c(%ebp),%edx
+f0100ac1:	b8 b4 1f 10 f0       	mov    $0xf0101fb4,%eax
+f0100ac6:	e8 74 fe ff ff       	call   f010093f <stab_binsearch>
+	if (lfile == 0)
+f0100acb:	8b 45 e4             	mov    -0x1c(%ebp),%eax
+f0100ace:	83 c4 10             	add    $0x10,%esp
+f0100ad1:	85 c0                	test   %eax,%eax
+f0100ad3:	0f 84 1b 01 00 00    	je     f0100bf4 <debuginfo_eip+0x1c0>
+		return -1;
+
+	// Search within that file's stabs for the function definition
+	// (N_FUN).
+	lfun = lfile;
+f0100ad9:	89 45 dc             	mov    %eax,-0x24(%ebp)
+	rfun = rfile;
+f0100adc:	8b 45 e0             	mov    -0x20(%ebp),%eax
+f0100adf:	89 45 d8             	mov    %eax,-0x28(%ebp)
+	stab_binsearch(stabs, &lfun, &rfun, N_FUN, addr);
+f0100ae2:	83 ec 08             	sub    $0x8,%esp
+f0100ae5:	57                   	push   %edi
+f0100ae6:	6a 24                	push   $0x24
+f0100ae8:	8d 4d d8             	lea    -0x28(%ebp),%ecx
+f0100aeb:	8d 55 dc             	lea    -0x24(%ebp),%edx
+f0100aee:	b8 b4 1f 10 f0       	mov    $0xf0101fb4,%eax
+f0100af3:	e8 47 fe ff ff       	call   f010093f <stab_binsearch>
+
+	if (lfun <= rfun) {
+f0100af8:	8b 5d dc             	mov    -0x24(%ebp),%ebx
+f0100afb:	83 c4 10             	add    $0x10,%esp
+f0100afe:	3b 5d d8             	cmp    -0x28(%ebp),%ebx
+f0100b01:	7f 64                	jg     f0100b67 <debuginfo_eip+0x133>
+		// stabs[lfun] points to the function name
+		// in the string table, but check bounds just in case.
+		if (stabs[lfun].n_strx < stabstr_end - stabstr)
+f0100b03:	8d 04 5b             	lea    (%ebx,%ebx,2),%eax
+f0100b06:	c1 e0 02             	shl    $0x2,%eax
+f0100b09:	8d 90 b4 1f 10 f0    	lea    -0xfefe04c(%eax),%edx
+f0100b0f:	8b 88 b4 1f 10 f0    	mov    -0xfefe04c(%eax),%ecx
+f0100b15:	b8 d7 7b 10 f0       	mov    $0xf0107bd7,%eax
+f0100b1a:	2d 2d 62 10 f0       	sub    $0xf010622d,%eax
+f0100b1f:	39 c1                	cmp    %eax,%ecx
+f0100b21:	73 09                	jae    f0100b2c <debuginfo_eip+0xf8>
+			info->eip_fn_name = stabstr + stabs[lfun].n_strx;
+f0100b23:	81 c1 2d 62 10 f0    	add    $0xf010622d,%ecx
+f0100b29:	89 4e 08             	mov    %ecx,0x8(%esi)
+		info->eip_fn_addr = stabs[lfun].n_value;
+f0100b2c:	8b 42 08             	mov    0x8(%edx),%eax
+f0100b2f:	89 46 10             	mov    %eax,0x10(%esi)
+		info->eip_fn_addr = addr;
+		lline = lfile;
+		rline = rfile;
+	}
+	// Ignore stuff after the colon.
+	info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name;
+f0100b32:	83 ec 08             	sub    $0x8,%esp
+f0100b35:	6a 3a                	push   $0x3a
+f0100b37:	ff 76 08             	pushl  0x8(%esi)
+f0100b3a:	e8 bc 08 00 00       	call   f01013fb <strfind>
+f0100b3f:	2b 46 08             	sub    0x8(%esi),%eax
+f0100b42:	89 46 0c             	mov    %eax,0xc(%esi)
+	// Search backwards from the line number for the relevant filename
+	// stab.
+	// We can't just use the "lfile" stab because inlined functions
+	// can interpolate code from a different file!
+	// Such included source files use the N_SOL stab type.
+	while (lline >= lfile
+f0100b45:	8b 4d e4             	mov    -0x1c(%ebp),%ecx
+f0100b48:	8d 04 5b             	lea    (%ebx,%ebx,2),%eax
+f0100b4b:	c1 e0 02             	shl    $0x2,%eax
+f0100b4e:	83 c4 10             	add    $0x10,%esp
+f0100b51:	eb 22                	jmp    f0100b75 <debuginfo_eip+0x141>
+  	        panic("User address");
+f0100b53:	83 ec 04             	sub    $0x4,%esp
+f0100b56:	68 86 1d 10 f0       	push   $0xf0101d86
+f0100b5b:	6a 7f                	push   $0x7f
+f0100b5d:	68 93 1d 10 f0       	push   $0xf0101d93
+f0100b62:	e8 87 f5 ff ff       	call   f01000ee <_panic>
+		info->eip_fn_addr = addr;
+f0100b67:	89 7e 10             	mov    %edi,0x10(%esi)
+		lline = lfile;
+f0100b6a:	8b 5d e4             	mov    -0x1c(%ebp),%ebx
+f0100b6d:	eb c3                	jmp    f0100b32 <debuginfo_eip+0xfe>
+	       && stabs[lline].n_type != N_SOL
+	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value))
+		lline--;
+f0100b6f:	83 eb 01             	sub    $0x1,%ebx
+f0100b72:	83 e8 0c             	sub    $0xc,%eax
+	while (lline >= lfile
+f0100b75:	39 d9                	cmp    %ebx,%ecx
+f0100b77:	7f 3a                	jg     f0100bb3 <debuginfo_eip+0x17f>
+	       && stabs[lline].n_type != N_SOL
+f0100b79:	0f b6 90 b8 1f 10 f0 	movzbl -0xfefe048(%eax),%edx
+f0100b80:	80 fa 84             	cmp    $0x84,%dl
+f0100b83:	74 0e                	je     f0100b93 <debuginfo_eip+0x15f>
+	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value))
+f0100b85:	80 fa 64             	cmp    $0x64,%dl
+f0100b88:	75 e5                	jne    f0100b6f <debuginfo_eip+0x13b>
+f0100b8a:	83 b8 bc 1f 10 f0 00 	cmpl   $0x0,-0xfefe044(%eax)
+f0100b91:	74 dc                	je     f0100b6f <debuginfo_eip+0x13b>
+	if (lline >= lfile && stabs[lline].n_strx < stabstr_end - stabstr)
+f0100b93:	8d 04 5b             	lea    (%ebx,%ebx,2),%eax
+f0100b96:	8b 14 85 b4 1f 10 f0 	mov    -0xfefe04c(,%eax,4),%edx
+f0100b9d:	b8 d7 7b 10 f0       	mov    $0xf0107bd7,%eax
+f0100ba2:	2d 2d 62 10 f0       	sub    $0xf010622d,%eax
+f0100ba7:	39 c2                	cmp    %eax,%edx
+f0100ba9:	73 08                	jae    f0100bb3 <debuginfo_eip+0x17f>
+		info->eip_file = stabstr + stabs[lline].n_strx;
+f0100bab:	81 c2 2d 62 10 f0    	add    $0xf010622d,%edx
+f0100bb1:	89 16                	mov    %edx,(%esi)
+
+
+	// Set eip_fn_narg to the number of arguments taken by the function,
+	// or 0 if there was no containing function.
+	if (lfun < rfun)
+f0100bb3:	8b 45 dc             	mov    -0x24(%ebp),%eax
+f0100bb6:	8b 4d d8             	mov    -0x28(%ebp),%ecx
+		for (lline = lfun + 1;
+		     lline < rfun && stabs[lline].n_type == N_PSYM;
+		     lline++)
+			info->eip_fn_narg++;
+
+	return 0;
+f0100bb9:	ba 00 00 00 00       	mov    $0x0,%edx
+	if (lfun < rfun)
+f0100bbe:	39 c8                	cmp    %ecx,%eax
+f0100bc0:	7d 3e                	jge    f0100c00 <debuginfo_eip+0x1cc>
+		for (lline = lfun + 1;
+f0100bc2:	83 c0 01             	add    $0x1,%eax
+f0100bc5:	eb 07                	jmp    f0100bce <debuginfo_eip+0x19a>
+			info->eip_fn_narg++;
+f0100bc7:	83 46 14 01          	addl   $0x1,0x14(%esi)
+		     lline++)
+f0100bcb:	83 c0 01             	add    $0x1,%eax
+		for (lline = lfun + 1;
+f0100bce:	39 c1                	cmp    %eax,%ecx
+f0100bd0:	74 29                	je     f0100bfb <debuginfo_eip+0x1c7>
+		     lline < rfun && stabs[lline].n_type == N_PSYM;
+f0100bd2:	8d 14 40             	lea    (%eax,%eax,2),%edx
+f0100bd5:	80 3c 95 b8 1f 10 f0 	cmpb   $0xa0,-0xfefe048(,%edx,4)
+f0100bdc:	a0 
+f0100bdd:	74 e8                	je     f0100bc7 <debuginfo_eip+0x193>
+	return 0;
+f0100bdf:	ba 00 00 00 00       	mov    $0x0,%edx
+f0100be4:	eb 1a                	jmp    f0100c00 <debuginfo_eip+0x1cc>
+		return -1;
+f0100be6:	ba ff ff ff ff       	mov    $0xffffffff,%edx
+f0100beb:	eb 13                	jmp    f0100c00 <debuginfo_eip+0x1cc>
+f0100bed:	ba ff ff ff ff       	mov    $0xffffffff,%edx
+f0100bf2:	eb 0c                	jmp    f0100c00 <debuginfo_eip+0x1cc>
+		return -1;
+f0100bf4:	ba ff ff ff ff       	mov    $0xffffffff,%edx
+f0100bf9:	eb 05                	jmp    f0100c00 <debuginfo_eip+0x1cc>
+	return 0;
+f0100bfb:	ba 00 00 00 00       	mov    $0x0,%edx
+}
+f0100c00:	89 d0                	mov    %edx,%eax
+f0100c02:	8d 65 f4             	lea    -0xc(%ebp),%esp
+f0100c05:	5b                   	pop    %ebx
+f0100c06:	5e                   	pop    %esi
+f0100c07:	5f                   	pop    %edi
+f0100c08:	5d                   	pop    %ebp
+f0100c09:	c3                   	ret    
+
+f0100c0a <printnum>:
+ * using specified putch function and associated pointer putdat.
+ */
+static void
+printnum(void (*putch)(int, void*), void *putdat,
+	 unsigned long long num, unsigned base, int width, int padc)
+{
+f0100c0a:	55                   	push   %ebp
+f0100c0b:	89 e5                	mov    %esp,%ebp
+f0100c0d:	57                   	push   %edi
+f0100c0e:	56                   	push   %esi
+f0100c0f:	53                   	push   %ebx
+f0100c10:	83 ec 1c             	sub    $0x1c,%esp
+f0100c13:	89 c7                	mov    %eax,%edi
+f0100c15:	89 d6                	mov    %edx,%esi
+f0100c17:	8b 45 08             	mov    0x8(%ebp),%eax
+f0100c1a:	8b 55 0c             	mov    0xc(%ebp),%edx
+f0100c1d:	89 d1                	mov    %edx,%ecx
+f0100c1f:	89 c2                	mov    %eax,%edx
+f0100c21:	89 45 d8             	mov    %eax,-0x28(%ebp)
+f0100c24:	89 4d dc             	mov    %ecx,-0x24(%ebp)
+f0100c27:	8b 45 10             	mov    0x10(%ebp),%eax
+f0100c2a:	8b 5d 14             	mov    0x14(%ebp),%ebx
+	// first recursively print all preceding (more significant) digits
+	if (num >= base) {
+f0100c2d:	89 45 e0             	mov    %eax,-0x20(%ebp)
+f0100c30:	c7 45 e4 00 00 00 00 	movl   $0x0,-0x1c(%ebp)
+f0100c37:	39 c2                	cmp    %eax,%edx
+f0100c39:	1b 4d e4             	sbb    -0x1c(%ebp),%ecx
+f0100c3c:	72 3e                	jb     f0100c7c <printnum+0x72>
+		printnum(putch, putdat, num / base, base, width - 1, padc);
+f0100c3e:	83 ec 0c             	sub    $0xc,%esp
+f0100c41:	ff 75 18             	pushl  0x18(%ebp)
+f0100c44:	83 eb 01             	sub    $0x1,%ebx
+f0100c47:	53                   	push   %ebx
+f0100c48:	50                   	push   %eax
+f0100c49:	83 ec 08             	sub    $0x8,%esp
+f0100c4c:	ff 75 e4             	pushl  -0x1c(%ebp)
+f0100c4f:	ff 75 e0             	pushl  -0x20(%ebp)
+f0100c52:	ff 75 dc             	pushl  -0x24(%ebp)
+f0100c55:	ff 75 d8             	pushl  -0x28(%ebp)
+f0100c58:	e8 d3 09 00 00       	call   f0101630 <__udivdi3>
+f0100c5d:	83 c4 18             	add    $0x18,%esp
+f0100c60:	52                   	push   %edx
+f0100c61:	50                   	push   %eax
+f0100c62:	89 f2                	mov    %esi,%edx
+f0100c64:	89 f8                	mov    %edi,%eax
+f0100c66:	e8 9f ff ff ff       	call   f0100c0a <printnum>
+f0100c6b:	83 c4 20             	add    $0x20,%esp
+f0100c6e:	eb 13                	jmp    f0100c83 <printnum+0x79>
+	} else {
+		// print any needed pad characters before first digit
+		while (--width > 0)
+			putch(padc, putdat);
+f0100c70:	83 ec 08             	sub    $0x8,%esp
+f0100c73:	56                   	push   %esi
+f0100c74:	ff 75 18             	pushl  0x18(%ebp)
+f0100c77:	ff d7                	call   *%edi
+f0100c79:	83 c4 10             	add    $0x10,%esp
+		while (--width > 0)
+f0100c7c:	83 eb 01             	sub    $0x1,%ebx
+f0100c7f:	85 db                	test   %ebx,%ebx
+f0100c81:	7f ed                	jg     f0100c70 <printnum+0x66>
+	}
+
+	// then print this (the least significant) digit
+	putch("0123456789abcdef"[num % base], putdat);
+f0100c83:	83 ec 08             	sub    $0x8,%esp
+f0100c86:	56                   	push   %esi
+f0100c87:	83 ec 04             	sub    $0x4,%esp
+f0100c8a:	ff 75 e4             	pushl  -0x1c(%ebp)
+f0100c8d:	ff 75 e0             	pushl  -0x20(%ebp)
+f0100c90:	ff 75 dc             	pushl  -0x24(%ebp)
+f0100c93:	ff 75 d8             	pushl  -0x28(%ebp)
+f0100c96:	e8 a5 0a 00 00       	call   f0101740 <__umoddi3>
+f0100c9b:	83 c4 14             	add    $0x14,%esp
+f0100c9e:	0f be 80 a1 1d 10 f0 	movsbl -0xfefe25f(%eax),%eax
+f0100ca5:	50                   	push   %eax
+f0100ca6:	ff d7                	call   *%edi
+}
+f0100ca8:	83 c4 10             	add    $0x10,%esp
+f0100cab:	8d 65 f4             	lea    -0xc(%ebp),%esp
+f0100cae:	5b                   	pop    %ebx
+f0100caf:	5e                   	pop    %esi
+f0100cb0:	5f                   	pop    %edi
+f0100cb1:	5d                   	pop    %ebp
+f0100cb2:	c3                   	ret    
+
+f0100cb3 <sprintputch>:
+	int cnt;
+};
+
+static void
+sprintputch(int ch, struct sprintbuf *b)
+{
+f0100cb3:	f3 0f 1e fb          	endbr32 
+f0100cb7:	55                   	push   %ebp
+f0100cb8:	89 e5                	mov    %esp,%ebp
+f0100cba:	8b 45 0c             	mov    0xc(%ebp),%eax
+	b->cnt++;
+f0100cbd:	83 40 08 01          	addl   $0x1,0x8(%eax)
+	if (b->buf < b->ebuf)
+f0100cc1:	8b 10                	mov    (%eax),%edx
+f0100cc3:	3b 50 04             	cmp    0x4(%eax),%edx
+f0100cc6:	73 0a                	jae    f0100cd2 <sprintputch+0x1f>
+		*b->buf++ = ch;
+f0100cc8:	8d 4a 01             	lea    0x1(%edx),%ecx
+f0100ccb:	89 08                	mov    %ecx,(%eax)
+f0100ccd:	8b 45 08             	mov    0x8(%ebp),%eax
+f0100cd0:	88 02                	mov    %al,(%edx)
+}
+f0100cd2:	5d                   	pop    %ebp
+f0100cd3:	c3                   	ret    
+
+f0100cd4 <printfmt>:
+{
+f0100cd4:	f3 0f 1e fb          	endbr32 
+f0100cd8:	55                   	push   %ebp
+f0100cd9:	89 e5                	mov    %esp,%ebp
+f0100cdb:	83 ec 08             	sub    $0x8,%esp
+	va_start(ap, fmt);
+f0100cde:	8d 45 14             	lea    0x14(%ebp),%eax
+	vprintfmt(putch, putdat, fmt, ap);
+f0100ce1:	50                   	push   %eax
+f0100ce2:	ff 75 10             	pushl  0x10(%ebp)
+f0100ce5:	ff 75 0c             	pushl  0xc(%ebp)
+f0100ce8:	ff 75 08             	pushl  0x8(%ebp)
+f0100ceb:	e8 05 00 00 00       	call   f0100cf5 <vprintfmt>
+}
+f0100cf0:	83 c4 10             	add    $0x10,%esp
+f0100cf3:	c9                   	leave  
+f0100cf4:	c3                   	ret    
+
+f0100cf5 <vprintfmt>:
+{
+f0100cf5:	f3 0f 1e fb          	endbr32 
+f0100cf9:	55                   	push   %ebp
+f0100cfa:	89 e5                	mov    %esp,%ebp
+f0100cfc:	57                   	push   %edi
+f0100cfd:	56                   	push   %esi
+f0100cfe:	53                   	push   %ebx
+f0100cff:	83 ec 3c             	sub    $0x3c,%esp
+f0100d02:	8b 75 08             	mov    0x8(%ebp),%esi
+f0100d05:	8b 5d 0c             	mov    0xc(%ebp),%ebx
+f0100d08:	8b 7d 10             	mov    0x10(%ebp),%edi
+f0100d0b:	e9 5d 03 00 00       	jmp    f010106d <vprintfmt+0x378>
+		padc = ' ';
+f0100d10:	c6 45 d3 20          	movb   $0x20,-0x2d(%ebp)
+		altflag = 0;
+f0100d14:	c7 45 e0 00 00 00 00 	movl   $0x0,-0x20(%ebp)
+		precision = -1;
+f0100d1b:	c7 45 d8 ff ff ff ff 	movl   $0xffffffff,-0x28(%ebp)
+		width = -1;
+f0100d22:	c7 45 d4 ff ff ff ff 	movl   $0xffffffff,-0x2c(%ebp)
+		lflag = 0;
+f0100d29:	b9 00 00 00 00       	mov    $0x0,%ecx
+		switch (ch = *(unsigned char *) fmt++) {
+f0100d2e:	8d 47 01             	lea    0x1(%edi),%eax
+f0100d31:	89 45 e4             	mov    %eax,-0x1c(%ebp)
+f0100d34:	0f b6 17             	movzbl (%edi),%edx
+f0100d37:	8d 42 dd             	lea    -0x23(%edx),%eax
+f0100d3a:	3c 55                	cmp    $0x55,%al
+f0100d3c:	0f 87 ae 03 00 00    	ja     f01010f0 <vprintfmt+0x3fb>
+f0100d42:	0f b6 c0             	movzbl %al,%eax
+f0100d45:	3e ff 24 85 30 1e 10 	notrack jmp *-0xfefe1d0(,%eax,4)
+f0100d4c:	f0 
+f0100d4d:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+			padc = '-';
+f0100d50:	c6 45 d3 2d          	movb   $0x2d,-0x2d(%ebp)
+f0100d54:	eb d8                	jmp    f0100d2e <vprintfmt+0x39>
+		switch (ch = *(unsigned char *) fmt++) {
+f0100d56:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+f0100d59:	c6 45 d3 30          	movb   $0x30,-0x2d(%ebp)
+f0100d5d:	eb cf                	jmp    f0100d2e <vprintfmt+0x39>
+f0100d5f:	0f b6 d2             	movzbl %dl,%edx
+f0100d62:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+			for (precision = 0; ; ++fmt) {
+f0100d65:	b8 00 00 00 00       	mov    $0x0,%eax
+f0100d6a:	89 4d e4             	mov    %ecx,-0x1c(%ebp)
+				precision = precision * 10 + ch - '0';
+f0100d6d:	8d 04 80             	lea    (%eax,%eax,4),%eax
+f0100d70:	8d 44 42 d0          	lea    -0x30(%edx,%eax,2),%eax
+				ch = *fmt;
+f0100d74:	0f be 17             	movsbl (%edi),%edx
+				if (ch < '0' || ch > '9')
+f0100d77:	8d 4a d0             	lea    -0x30(%edx),%ecx
+f0100d7a:	83 f9 09             	cmp    $0x9,%ecx
+f0100d7d:	77 55                	ja     f0100dd4 <vprintfmt+0xdf>
+			for (precision = 0; ; ++fmt) {
+f0100d7f:	83 c7 01             	add    $0x1,%edi
+				precision = precision * 10 + ch - '0';
+f0100d82:	eb e9                	jmp    f0100d6d <vprintfmt+0x78>
+			precision = va_arg(ap, int);
+f0100d84:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100d87:	8b 00                	mov    (%eax),%eax
+f0100d89:	89 45 d8             	mov    %eax,-0x28(%ebp)
+f0100d8c:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100d8f:	8d 40 04             	lea    0x4(%eax),%eax
+f0100d92:	89 45 14             	mov    %eax,0x14(%ebp)
+		switch (ch = *(unsigned char *) fmt++) {
+f0100d95:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+			if (width < 0)
+f0100d98:	83 7d d4 00          	cmpl   $0x0,-0x2c(%ebp)
+f0100d9c:	79 90                	jns    f0100d2e <vprintfmt+0x39>
+				width = precision, precision = -1;
+f0100d9e:	8b 45 d8             	mov    -0x28(%ebp),%eax
+f0100da1:	89 45 d4             	mov    %eax,-0x2c(%ebp)
+f0100da4:	c7 45 d8 ff ff ff ff 	movl   $0xffffffff,-0x28(%ebp)
+f0100dab:	eb 81                	jmp    f0100d2e <vprintfmt+0x39>
+f0100dad:	8b 45 d4             	mov    -0x2c(%ebp),%eax
+f0100db0:	85 c0                	test   %eax,%eax
+f0100db2:	ba 00 00 00 00       	mov    $0x0,%edx
+f0100db7:	0f 49 d0             	cmovns %eax,%edx
+f0100dba:	89 55 d4             	mov    %edx,-0x2c(%ebp)
+		switch (ch = *(unsigned char *) fmt++) {
+f0100dbd:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+			goto reswitch;
+f0100dc0:	e9 69 ff ff ff       	jmp    f0100d2e <vprintfmt+0x39>
+		switch (ch = *(unsigned char *) fmt++) {
+f0100dc5:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+			altflag = 1;
+f0100dc8:	c7 45 e0 01 00 00 00 	movl   $0x1,-0x20(%ebp)
+			goto reswitch;
+f0100dcf:	e9 5a ff ff ff       	jmp    f0100d2e <vprintfmt+0x39>
+f0100dd4:	8b 4d e4             	mov    -0x1c(%ebp),%ecx
+f0100dd7:	89 45 d8             	mov    %eax,-0x28(%ebp)
+f0100dda:	eb bc                	jmp    f0100d98 <vprintfmt+0xa3>
+			lflag++;
+f0100ddc:	83 c1 01             	add    $0x1,%ecx
+		switch (ch = *(unsigned char *) fmt++) {
+f0100ddf:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+			goto reswitch;
+f0100de2:	e9 47 ff ff ff       	jmp    f0100d2e <vprintfmt+0x39>
+			putch(va_arg(ap, int), putdat);
+f0100de7:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100dea:	8d 78 04             	lea    0x4(%eax),%edi
+f0100ded:	83 ec 08             	sub    $0x8,%esp
+f0100df0:	53                   	push   %ebx
+f0100df1:	ff 30                	pushl  (%eax)
+f0100df3:	ff d6                	call   *%esi
+			break;
+f0100df5:	83 c4 10             	add    $0x10,%esp
+			putch(va_arg(ap, int), putdat);
+f0100df8:	89 7d 14             	mov    %edi,0x14(%ebp)
+			break;
+f0100dfb:	e9 6a 02 00 00       	jmp    f010106a <vprintfmt+0x375>
+			err = va_arg(ap, int);
+f0100e00:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100e03:	8d 78 04             	lea    0x4(%eax),%edi
+f0100e06:	8b 00                	mov    (%eax),%eax
+f0100e08:	99                   	cltd   
+f0100e09:	31 d0                	xor    %edx,%eax
+f0100e0b:	29 d0                	sub    %edx,%eax
+			if (err >= MAXERROR || (p = error_string[err]) == NULL)
+f0100e0d:	83 f8 06             	cmp    $0x6,%eax
+f0100e10:	7f 23                	jg     f0100e35 <vprintfmt+0x140>
+f0100e12:	8b 14 85 88 1f 10 f0 	mov    -0xfefe078(,%eax,4),%edx
+f0100e19:	85 d2                	test   %edx,%edx
+f0100e1b:	74 18                	je     f0100e35 <vprintfmt+0x140>
+				printfmt(putch, putdat, "%s", p);
+f0100e1d:	52                   	push   %edx
+f0100e1e:	68 c2 1d 10 f0       	push   $0xf0101dc2
+f0100e23:	53                   	push   %ebx
+f0100e24:	56                   	push   %esi
+f0100e25:	e8 aa fe ff ff       	call   f0100cd4 <printfmt>
+f0100e2a:	83 c4 10             	add    $0x10,%esp
+			err = va_arg(ap, int);
+f0100e2d:	89 7d 14             	mov    %edi,0x14(%ebp)
+f0100e30:	e9 35 02 00 00       	jmp    f010106a <vprintfmt+0x375>
+				printfmt(putch, putdat, "error %d", err);
+f0100e35:	50                   	push   %eax
+f0100e36:	68 b9 1d 10 f0       	push   $0xf0101db9
+f0100e3b:	53                   	push   %ebx
+f0100e3c:	56                   	push   %esi
+f0100e3d:	e8 92 fe ff ff       	call   f0100cd4 <printfmt>
+f0100e42:	83 c4 10             	add    $0x10,%esp
+			err = va_arg(ap, int);
+f0100e45:	89 7d 14             	mov    %edi,0x14(%ebp)
+				printfmt(putch, putdat, "error %d", err);
+f0100e48:	e9 1d 02 00 00       	jmp    f010106a <vprintfmt+0x375>
+			if ((p = va_arg(ap, char *)) == NULL)
+f0100e4d:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100e50:	83 c0 04             	add    $0x4,%eax
+f0100e53:	89 45 c8             	mov    %eax,-0x38(%ebp)
+f0100e56:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100e59:	8b 10                	mov    (%eax),%edx
+				p = "(null)";
+f0100e5b:	85 d2                	test   %edx,%edx
+f0100e5d:	b8 b2 1d 10 f0       	mov    $0xf0101db2,%eax
+f0100e62:	0f 45 c2             	cmovne %edx,%eax
+f0100e65:	89 45 cc             	mov    %eax,-0x34(%ebp)
+			if (width > 0 && padc != '-')
+f0100e68:	83 7d d4 00          	cmpl   $0x0,-0x2c(%ebp)
+f0100e6c:	7e 06                	jle    f0100e74 <vprintfmt+0x17f>
+f0100e6e:	80 7d d3 2d          	cmpb   $0x2d,-0x2d(%ebp)
+f0100e72:	75 0d                	jne    f0100e81 <vprintfmt+0x18c>
+				for (width -= strnlen(p, precision); width > 0; width--)
+f0100e74:	8b 45 cc             	mov    -0x34(%ebp),%eax
+f0100e77:	89 c7                	mov    %eax,%edi
+f0100e79:	03 45 d4             	add    -0x2c(%ebp),%eax
+f0100e7c:	89 45 d4             	mov    %eax,-0x2c(%ebp)
+f0100e7f:	eb 55                	jmp    f0100ed6 <vprintfmt+0x1e1>
+f0100e81:	83 ec 08             	sub    $0x8,%esp
+f0100e84:	ff 75 d8             	pushl  -0x28(%ebp)
+f0100e87:	ff 75 cc             	pushl  -0x34(%ebp)
+f0100e8a:	e8 fb 03 00 00       	call   f010128a <strnlen>
+f0100e8f:	8b 55 d4             	mov    -0x2c(%ebp),%edx
+f0100e92:	29 c2                	sub    %eax,%edx
+f0100e94:	89 55 c4             	mov    %edx,-0x3c(%ebp)
+f0100e97:	83 c4 10             	add    $0x10,%esp
+f0100e9a:	89 d7                	mov    %edx,%edi
+					putch(padc, putdat);
+f0100e9c:	0f be 45 d3          	movsbl -0x2d(%ebp),%eax
+f0100ea0:	89 45 d4             	mov    %eax,-0x2c(%ebp)
+				for (width -= strnlen(p, precision); width > 0; width--)
+f0100ea3:	85 ff                	test   %edi,%edi
+f0100ea5:	7e 11                	jle    f0100eb8 <vprintfmt+0x1c3>
+					putch(padc, putdat);
+f0100ea7:	83 ec 08             	sub    $0x8,%esp
+f0100eaa:	53                   	push   %ebx
+f0100eab:	ff 75 d4             	pushl  -0x2c(%ebp)
+f0100eae:	ff d6                	call   *%esi
+				for (width -= strnlen(p, precision); width > 0; width--)
+f0100eb0:	83 ef 01             	sub    $0x1,%edi
+f0100eb3:	83 c4 10             	add    $0x10,%esp
+f0100eb6:	eb eb                	jmp    f0100ea3 <vprintfmt+0x1ae>
+f0100eb8:	8b 55 c4             	mov    -0x3c(%ebp),%edx
+f0100ebb:	85 d2                	test   %edx,%edx
+f0100ebd:	b8 00 00 00 00       	mov    $0x0,%eax
+f0100ec2:	0f 49 c2             	cmovns %edx,%eax
+f0100ec5:	29 c2                	sub    %eax,%edx
+f0100ec7:	89 55 d4             	mov    %edx,-0x2c(%ebp)
+f0100eca:	eb a8                	jmp    f0100e74 <vprintfmt+0x17f>
+					putch(ch, putdat);
+f0100ecc:	83 ec 08             	sub    $0x8,%esp
+f0100ecf:	53                   	push   %ebx
+f0100ed0:	52                   	push   %edx
+f0100ed1:	ff d6                	call   *%esi
+f0100ed3:	83 c4 10             	add    $0x10,%esp
+f0100ed6:	8b 4d d4             	mov    -0x2c(%ebp),%ecx
+f0100ed9:	29 f9                	sub    %edi,%ecx
+			for (; (ch = *p++) != '\0' && (precision < 0 || --precision >= 0); width--)
+f0100edb:	83 c7 01             	add    $0x1,%edi
+f0100ede:	0f b6 47 ff          	movzbl -0x1(%edi),%eax
+f0100ee2:	0f be d0             	movsbl %al,%edx
+f0100ee5:	85 d2                	test   %edx,%edx
+f0100ee7:	74 4b                	je     f0100f34 <vprintfmt+0x23f>
+f0100ee9:	83 7d d8 00          	cmpl   $0x0,-0x28(%ebp)
+f0100eed:	78 06                	js     f0100ef5 <vprintfmt+0x200>
+f0100eef:	83 6d d8 01          	subl   $0x1,-0x28(%ebp)
+f0100ef3:	78 1e                	js     f0100f13 <vprintfmt+0x21e>
+				if (altflag && (ch < ' ' || ch > '~'))
+f0100ef5:	83 7d e0 00          	cmpl   $0x0,-0x20(%ebp)
+f0100ef9:	74 d1                	je     f0100ecc <vprintfmt+0x1d7>
+f0100efb:	0f be c0             	movsbl %al,%eax
+f0100efe:	83 e8 20             	sub    $0x20,%eax
+f0100f01:	83 f8 5e             	cmp    $0x5e,%eax
+f0100f04:	76 c6                	jbe    f0100ecc <vprintfmt+0x1d7>
+					putch('?', putdat);
+f0100f06:	83 ec 08             	sub    $0x8,%esp
+f0100f09:	53                   	push   %ebx
+f0100f0a:	6a 3f                	push   $0x3f
+f0100f0c:	ff d6                	call   *%esi
+f0100f0e:	83 c4 10             	add    $0x10,%esp
+f0100f11:	eb c3                	jmp    f0100ed6 <vprintfmt+0x1e1>
+f0100f13:	89 cf                	mov    %ecx,%edi
+f0100f15:	eb 0e                	jmp    f0100f25 <vprintfmt+0x230>
+				putch(' ', putdat);
+f0100f17:	83 ec 08             	sub    $0x8,%esp
+f0100f1a:	53                   	push   %ebx
+f0100f1b:	6a 20                	push   $0x20
+f0100f1d:	ff d6                	call   *%esi
+			for (; width > 0; width--)
+f0100f1f:	83 ef 01             	sub    $0x1,%edi
+f0100f22:	83 c4 10             	add    $0x10,%esp
+f0100f25:	85 ff                	test   %edi,%edi
+f0100f27:	7f ee                	jg     f0100f17 <vprintfmt+0x222>
+			if ((p = va_arg(ap, char *)) == NULL)
+f0100f29:	8b 45 c8             	mov    -0x38(%ebp),%eax
+f0100f2c:	89 45 14             	mov    %eax,0x14(%ebp)
+f0100f2f:	e9 36 01 00 00       	jmp    f010106a <vprintfmt+0x375>
+f0100f34:	89 cf                	mov    %ecx,%edi
+f0100f36:	eb ed                	jmp    f0100f25 <vprintfmt+0x230>
+	if (lflag >= 2)
+f0100f38:	83 f9 01             	cmp    $0x1,%ecx
+f0100f3b:	7f 1f                	jg     f0100f5c <vprintfmt+0x267>
+	else if (lflag)
+f0100f3d:	85 c9                	test   %ecx,%ecx
+f0100f3f:	74 67                	je     f0100fa8 <vprintfmt+0x2b3>
+		return va_arg(*ap, long);
+f0100f41:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100f44:	8b 00                	mov    (%eax),%eax
+f0100f46:	89 45 d8             	mov    %eax,-0x28(%ebp)
+f0100f49:	89 c1                	mov    %eax,%ecx
+f0100f4b:	c1 f9 1f             	sar    $0x1f,%ecx
+f0100f4e:	89 4d dc             	mov    %ecx,-0x24(%ebp)
+f0100f51:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100f54:	8d 40 04             	lea    0x4(%eax),%eax
+f0100f57:	89 45 14             	mov    %eax,0x14(%ebp)
+f0100f5a:	eb 17                	jmp    f0100f73 <vprintfmt+0x27e>
+		return va_arg(*ap, long long);
+f0100f5c:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100f5f:	8b 50 04             	mov    0x4(%eax),%edx
+f0100f62:	8b 00                	mov    (%eax),%eax
+f0100f64:	89 45 d8             	mov    %eax,-0x28(%ebp)
+f0100f67:	89 55 dc             	mov    %edx,-0x24(%ebp)
+f0100f6a:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100f6d:	8d 40 08             	lea    0x8(%eax),%eax
+f0100f70:	89 45 14             	mov    %eax,0x14(%ebp)
+			if ((long long) num < 0) {
+f0100f73:	8b 55 d8             	mov    -0x28(%ebp),%edx
+f0100f76:	8b 4d dc             	mov    -0x24(%ebp),%ecx
+			base = 10;
+f0100f79:	b8 0a 00 00 00       	mov    $0xa,%eax
+			if ((long long) num < 0) {
+f0100f7e:	85 c9                	test   %ecx,%ecx
+f0100f80:	0f 89 ca 00 00 00    	jns    f0101050 <vprintfmt+0x35b>
+				putch('-', putdat);
+f0100f86:	83 ec 08             	sub    $0x8,%esp
+f0100f89:	53                   	push   %ebx
+f0100f8a:	6a 2d                	push   $0x2d
+f0100f8c:	ff d6                	call   *%esi
+				num = -(long long) num;
+f0100f8e:	8b 55 d8             	mov    -0x28(%ebp),%edx
+f0100f91:	8b 4d dc             	mov    -0x24(%ebp),%ecx
+f0100f94:	f7 da                	neg    %edx
+f0100f96:	83 d1 00             	adc    $0x0,%ecx
+f0100f99:	f7 d9                	neg    %ecx
+f0100f9b:	83 c4 10             	add    $0x10,%esp
+			base = 10;
+f0100f9e:	b8 0a 00 00 00       	mov    $0xa,%eax
+f0100fa3:	e9 a8 00 00 00       	jmp    f0101050 <vprintfmt+0x35b>
+		return va_arg(*ap, int);
+f0100fa8:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100fab:	8b 00                	mov    (%eax),%eax
+f0100fad:	89 45 d8             	mov    %eax,-0x28(%ebp)
+f0100fb0:	99                   	cltd   
+f0100fb1:	89 55 dc             	mov    %edx,-0x24(%ebp)
+f0100fb4:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100fb7:	8d 40 04             	lea    0x4(%eax),%eax
+f0100fba:	89 45 14             	mov    %eax,0x14(%ebp)
+f0100fbd:	eb b4                	jmp    f0100f73 <vprintfmt+0x27e>
+	if (lflag >= 2)
+f0100fbf:	83 f9 01             	cmp    $0x1,%ecx
+f0100fc2:	7f 1b                	jg     f0100fdf <vprintfmt+0x2ea>
+	else if (lflag)
+f0100fc4:	85 c9                	test   %ecx,%ecx
+f0100fc6:	74 2c                	je     f0100ff4 <vprintfmt+0x2ff>
+		return va_arg(*ap, unsigned long);
+f0100fc8:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100fcb:	8b 10                	mov    (%eax),%edx
+f0100fcd:	b9 00 00 00 00       	mov    $0x0,%ecx
+f0100fd2:	8d 40 04             	lea    0x4(%eax),%eax
+f0100fd5:	89 45 14             	mov    %eax,0x14(%ebp)
+			base = 10;
+f0100fd8:	b8 0a 00 00 00       	mov    $0xa,%eax
+		return va_arg(*ap, unsigned long);
+f0100fdd:	eb 71                	jmp    f0101050 <vprintfmt+0x35b>
+		return va_arg(*ap, unsigned long long);
+f0100fdf:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100fe2:	8b 10                	mov    (%eax),%edx
+f0100fe4:	8b 48 04             	mov    0x4(%eax),%ecx
+f0100fe7:	8d 40 08             	lea    0x8(%eax),%eax
+f0100fea:	89 45 14             	mov    %eax,0x14(%ebp)
+			base = 10;
+f0100fed:	b8 0a 00 00 00       	mov    $0xa,%eax
+		return va_arg(*ap, unsigned long long);
+f0100ff2:	eb 5c                	jmp    f0101050 <vprintfmt+0x35b>
+		return va_arg(*ap, unsigned int);
+f0100ff4:	8b 45 14             	mov    0x14(%ebp),%eax
+f0100ff7:	8b 10                	mov    (%eax),%edx
+f0100ff9:	b9 00 00 00 00       	mov    $0x0,%ecx
+f0100ffe:	8d 40 04             	lea    0x4(%eax),%eax
+f0101001:	89 45 14             	mov    %eax,0x14(%ebp)
+			base = 10;
+f0101004:	b8 0a 00 00 00       	mov    $0xa,%eax
+		return va_arg(*ap, unsigned int);
+f0101009:	eb 45                	jmp    f0101050 <vprintfmt+0x35b>
+			putch('X', putdat);
+f010100b:	83 ec 08             	sub    $0x8,%esp
+f010100e:	53                   	push   %ebx
+f010100f:	6a 58                	push   $0x58
+f0101011:	ff d6                	call   *%esi
+			putch('X', putdat);
+f0101013:	83 c4 08             	add    $0x8,%esp
+f0101016:	53                   	push   %ebx
+f0101017:	6a 58                	push   $0x58
+f0101019:	ff d6                	call   *%esi
+			putch('X', putdat);
+f010101b:	83 c4 08             	add    $0x8,%esp
+f010101e:	53                   	push   %ebx
+f010101f:	6a 58                	push   $0x58
+f0101021:	ff d6                	call   *%esi
+			break;
+f0101023:	83 c4 10             	add    $0x10,%esp
+f0101026:	eb 42                	jmp    f010106a <vprintfmt+0x375>
+			putch('0', putdat);
+f0101028:	83 ec 08             	sub    $0x8,%esp
+f010102b:	53                   	push   %ebx
+f010102c:	6a 30                	push   $0x30
+f010102e:	ff d6                	call   *%esi
+			putch('x', putdat);
+f0101030:	83 c4 08             	add    $0x8,%esp
+f0101033:	53                   	push   %ebx
+f0101034:	6a 78                	push   $0x78
+f0101036:	ff d6                	call   *%esi
+			num = (unsigned long long)
+f0101038:	8b 45 14             	mov    0x14(%ebp),%eax
+f010103b:	8b 10                	mov    (%eax),%edx
+f010103d:	b9 00 00 00 00       	mov    $0x0,%ecx
+			goto number;
+f0101042:	83 c4 10             	add    $0x10,%esp
+				(uintptr_t) va_arg(ap, void *);
+f0101045:	8d 40 04             	lea    0x4(%eax),%eax
+f0101048:	89 45 14             	mov    %eax,0x14(%ebp)
+			base = 16;
+f010104b:	b8 10 00 00 00       	mov    $0x10,%eax
+			printnum(putch, putdat, num, base, width, padc);
+f0101050:	83 ec 0c             	sub    $0xc,%esp
+f0101053:	0f be 7d d3          	movsbl -0x2d(%ebp),%edi
+f0101057:	57                   	push   %edi
+f0101058:	ff 75 d4             	pushl  -0x2c(%ebp)
+f010105b:	50                   	push   %eax
+f010105c:	51                   	push   %ecx
+f010105d:	52                   	push   %edx
+f010105e:	89 da                	mov    %ebx,%edx
+f0101060:	89 f0                	mov    %esi,%eax
+f0101062:	e8 a3 fb ff ff       	call   f0100c0a <printnum>
+			break;
+f0101067:	83 c4 20             	add    $0x20,%esp
+			if ((p = va_arg(ap, char *)) == NULL)
+f010106a:	8b 7d e4             	mov    -0x1c(%ebp),%edi
+		while ((ch = *(unsigned char *) fmt++) != '%') {
+f010106d:	83 c7 01             	add    $0x1,%edi
+f0101070:	0f b6 47 ff          	movzbl -0x1(%edi),%eax
+f0101074:	83 f8 25             	cmp    $0x25,%eax
+f0101077:	0f 84 93 fc ff ff    	je     f0100d10 <vprintfmt+0x1b>
+			if (ch == '\0')
+f010107d:	85 c0                	test   %eax,%eax
+f010107f:	0f 84 8b 00 00 00    	je     f0101110 <vprintfmt+0x41b>
+			putch(ch, putdat);
+f0101085:	83 ec 08             	sub    $0x8,%esp
+f0101088:	53                   	push   %ebx
+f0101089:	50                   	push   %eax
+f010108a:	ff d6                	call   *%esi
+f010108c:	83 c4 10             	add    $0x10,%esp
+f010108f:	eb dc                	jmp    f010106d <vprintfmt+0x378>
+	if (lflag >= 2)
+f0101091:	83 f9 01             	cmp    $0x1,%ecx
+f0101094:	7f 1b                	jg     f01010b1 <vprintfmt+0x3bc>
+	else if (lflag)
+f0101096:	85 c9                	test   %ecx,%ecx
+f0101098:	74 2c                	je     f01010c6 <vprintfmt+0x3d1>
+		return va_arg(*ap, unsigned long);
+f010109a:	8b 45 14             	mov    0x14(%ebp),%eax
+f010109d:	8b 10                	mov    (%eax),%edx
+f010109f:	b9 00 00 00 00       	mov    $0x0,%ecx
+f01010a4:	8d 40 04             	lea    0x4(%eax),%eax
+f01010a7:	89 45 14             	mov    %eax,0x14(%ebp)
+			base = 16;
+f01010aa:	b8 10 00 00 00       	mov    $0x10,%eax
+		return va_arg(*ap, unsigned long);
+f01010af:	eb 9f                	jmp    f0101050 <vprintfmt+0x35b>
+		return va_arg(*ap, unsigned long long);
+f01010b1:	8b 45 14             	mov    0x14(%ebp),%eax
+f01010b4:	8b 10                	mov    (%eax),%edx
+f01010b6:	8b 48 04             	mov    0x4(%eax),%ecx
+f01010b9:	8d 40 08             	lea    0x8(%eax),%eax
+f01010bc:	89 45 14             	mov    %eax,0x14(%ebp)
+			base = 16;
+f01010bf:	b8 10 00 00 00       	mov    $0x10,%eax
+		return va_arg(*ap, unsigned long long);
+f01010c4:	eb 8a                	jmp    f0101050 <vprintfmt+0x35b>
+		return va_arg(*ap, unsigned int);
+f01010c6:	8b 45 14             	mov    0x14(%ebp),%eax
+f01010c9:	8b 10                	mov    (%eax),%edx
+f01010cb:	b9 00 00 00 00       	mov    $0x0,%ecx
+f01010d0:	8d 40 04             	lea    0x4(%eax),%eax
+f01010d3:	89 45 14             	mov    %eax,0x14(%ebp)
+			base = 16;
+f01010d6:	b8 10 00 00 00       	mov    $0x10,%eax
+		return va_arg(*ap, unsigned int);
+f01010db:	e9 70 ff ff ff       	jmp    f0101050 <vprintfmt+0x35b>
+			putch(ch, putdat);
+f01010e0:	83 ec 08             	sub    $0x8,%esp
+f01010e3:	53                   	push   %ebx
+f01010e4:	6a 25                	push   $0x25
+f01010e6:	ff d6                	call   *%esi
+			break;
+f01010e8:	83 c4 10             	add    $0x10,%esp
+f01010eb:	e9 7a ff ff ff       	jmp    f010106a <vprintfmt+0x375>
+			putch('%', putdat);
+f01010f0:	83 ec 08             	sub    $0x8,%esp
+f01010f3:	53                   	push   %ebx
+f01010f4:	6a 25                	push   $0x25
+f01010f6:	ff d6                	call   *%esi
+			for (fmt--; fmt[-1] != '%'; fmt--)
+f01010f8:	83 c4 10             	add    $0x10,%esp
+f01010fb:	89 f8                	mov    %edi,%eax
+f01010fd:	80 78 ff 25          	cmpb   $0x25,-0x1(%eax)
+f0101101:	74 05                	je     f0101108 <vprintfmt+0x413>
+f0101103:	83 e8 01             	sub    $0x1,%eax
+f0101106:	eb f5                	jmp    f01010fd <vprintfmt+0x408>
+f0101108:	89 45 e4             	mov    %eax,-0x1c(%ebp)
+f010110b:	e9 5a ff ff ff       	jmp    f010106a <vprintfmt+0x375>
+}
+f0101110:	8d 65 f4             	lea    -0xc(%ebp),%esp
+f0101113:	5b                   	pop    %ebx
+f0101114:	5e                   	pop    %esi
+f0101115:	5f                   	pop    %edi
+f0101116:	5d                   	pop    %ebp
+f0101117:	c3                   	ret    
+
+f0101118 <vsnprintf>:
+
+int
+vsnprintf(char *buf, int n, const char *fmt, va_list ap)
+{
+f0101118:	f3 0f 1e fb          	endbr32 
+f010111c:	55                   	push   %ebp
+f010111d:	89 e5                	mov    %esp,%ebp
+f010111f:	83 ec 18             	sub    $0x18,%esp
+f0101122:	8b 45 08             	mov    0x8(%ebp),%eax
+f0101125:	8b 55 0c             	mov    0xc(%ebp),%edx
+	struct sprintbuf b = {buf, buf+n-1, 0};
+f0101128:	89 45 ec             	mov    %eax,-0x14(%ebp)
+f010112b:	8d 4c 10 ff          	lea    -0x1(%eax,%edx,1),%ecx
+f010112f:	89 4d f0             	mov    %ecx,-0x10(%ebp)
+f0101132:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
+
+	if (buf == NULL || n < 1)
+f0101139:	85 c0                	test   %eax,%eax
+f010113b:	74 26                	je     f0101163 <vsnprintf+0x4b>
+f010113d:	85 d2                	test   %edx,%edx
+f010113f:	7e 22                	jle    f0101163 <vsnprintf+0x4b>
+		return -E_INVAL;
+
+	// print the string to the buffer
+	vprintfmt((void*)sprintputch, &b, fmt, ap);
+f0101141:	ff 75 14             	pushl  0x14(%ebp)
+f0101144:	ff 75 10             	pushl  0x10(%ebp)
+f0101147:	8d 45 ec             	lea    -0x14(%ebp),%eax
+f010114a:	50                   	push   %eax
+f010114b:	68 b3 0c 10 f0       	push   $0xf0100cb3
+f0101150:	e8 a0 fb ff ff       	call   f0100cf5 <vprintfmt>
+
+	// null terminate the buffer
+	*b.buf = '\0';
+f0101155:	8b 45 ec             	mov    -0x14(%ebp),%eax
+f0101158:	c6 00 00             	movb   $0x0,(%eax)
+
+	return b.cnt;
+f010115b:	8b 45 f4             	mov    -0xc(%ebp),%eax
+f010115e:	83 c4 10             	add    $0x10,%esp
+}
+f0101161:	c9                   	leave  
+f0101162:	c3                   	ret    
+		return -E_INVAL;
+f0101163:	b8 fd ff ff ff       	mov    $0xfffffffd,%eax
+f0101168:	eb f7                	jmp    f0101161 <vsnprintf+0x49>
+
+f010116a <snprintf>:
+
+int
+snprintf(char *buf, int n, const char *fmt, ...)
+{
+f010116a:	f3 0f 1e fb          	endbr32 
+f010116e:	55                   	push   %ebp
+f010116f:	89 e5                	mov    %esp,%ebp
+f0101171:	83 ec 08             	sub    $0x8,%esp
+	va_list ap;
+	int rc;
+
+	va_start(ap, fmt);
+f0101174:	8d 45 14             	lea    0x14(%ebp),%eax
+	rc = vsnprintf(buf, n, fmt, ap);
+f0101177:	50                   	push   %eax
+f0101178:	ff 75 10             	pushl  0x10(%ebp)
+f010117b:	ff 75 0c             	pushl  0xc(%ebp)
+f010117e:	ff 75 08             	pushl  0x8(%ebp)
+f0101181:	e8 92 ff ff ff       	call   f0101118 <vsnprintf>
+	va_end(ap);
+
+	return rc;
+}
+f0101186:	c9                   	leave  
+f0101187:	c3                   	ret    
+
+f0101188 <readline>:
+#define BUFLEN 1024
+static char buf[BUFLEN];
+
+char *
+readline(const char *prompt)
+{
+f0101188:	f3 0f 1e fb          	endbr32 
+f010118c:	55                   	push   %ebp
+f010118d:	89 e5                	mov    %esp,%ebp
+f010118f:	57                   	push   %edi
+f0101190:	56                   	push   %esi
+f0101191:	53                   	push   %ebx
+f0101192:	83 ec 0c             	sub    $0xc,%esp
+f0101195:	8b 45 08             	mov    0x8(%ebp),%eax
+	int i, c, echoing;
+
+	if (prompt != NULL)
+f0101198:	85 c0                	test   %eax,%eax
+f010119a:	74 11                	je     f01011ad <readline+0x25>
+		cprintf("%s", prompt);
+f010119c:	83 ec 08             	sub    $0x8,%esp
+f010119f:	50                   	push   %eax
+f01011a0:	68 c2 1d 10 f0       	push   $0xf0101dc2
+f01011a5:	e8 7d f7 ff ff       	call   f0100927 <cprintf>
+f01011aa:	83 c4 10             	add    $0x10,%esp
+
+	i = 0;
+	echoing = iscons(0);
+f01011ad:	83 ec 0c             	sub    $0xc,%esp
+f01011b0:	6a 00                	push   $0x0
+f01011b2:	e8 f1 f4 ff ff       	call   f01006a8 <iscons>
+f01011b7:	89 c7                	mov    %eax,%edi
+f01011b9:	83 c4 10             	add    $0x10,%esp
+	i = 0;
+f01011bc:	be 00 00 00 00       	mov    $0x0,%esi
+f01011c1:	eb 4b                	jmp    f010120e <readline+0x86>
+	while (1) {
+		c = getchar();
+		if (c < 0) {
+			cprintf("read error: %e\n", c);
+f01011c3:	83 ec 08             	sub    $0x8,%esp
+f01011c6:	50                   	push   %eax
+f01011c7:	68 a4 1f 10 f0       	push   $0xf0101fa4
+f01011cc:	e8 56 f7 ff ff       	call   f0100927 <cprintf>
+			return NULL;
+f01011d1:	83 c4 10             	add    $0x10,%esp
+f01011d4:	b8 00 00 00 00       	mov    $0x0,%eax
+				cputchar('\n');
+			buf[i] = 0;
+			return buf;
+		}
+	}
+}
+f01011d9:	8d 65 f4             	lea    -0xc(%ebp),%esp
+f01011dc:	5b                   	pop    %ebx
+f01011dd:	5e                   	pop    %esi
+f01011de:	5f                   	pop    %edi
+f01011df:	5d                   	pop    %ebp
+f01011e0:	c3                   	ret    
+			if (echoing)
+f01011e1:	85 ff                	test   %edi,%edi
+f01011e3:	75 05                	jne    f01011ea <readline+0x62>
+			i--;
+f01011e5:	83 ee 01             	sub    $0x1,%esi
+f01011e8:	eb 24                	jmp    f010120e <readline+0x86>
+				cputchar('\b');
+f01011ea:	83 ec 0c             	sub    $0xc,%esp
+f01011ed:	6a 08                	push   $0x8
+f01011ef:	e8 8b f4 ff ff       	call   f010067f <cputchar>
+f01011f4:	83 c4 10             	add    $0x10,%esp
+f01011f7:	eb ec                	jmp    f01011e5 <readline+0x5d>
+				cputchar(c);
+f01011f9:	83 ec 0c             	sub    $0xc,%esp
+f01011fc:	53                   	push   %ebx
+f01011fd:	e8 7d f4 ff ff       	call   f010067f <cputchar>
+f0101202:	83 c4 10             	add    $0x10,%esp
+			buf[i++] = c;
+f0101205:	88 9e 40 25 11 f0    	mov    %bl,-0xfeedac0(%esi)
+f010120b:	8d 76 01             	lea    0x1(%esi),%esi
+		c = getchar();
+f010120e:	e8 80 f4 ff ff       	call   f0100693 <getchar>
+f0101213:	89 c3                	mov    %eax,%ebx
+		if (c < 0) {
+f0101215:	85 c0                	test   %eax,%eax
+f0101217:	78 aa                	js     f01011c3 <readline+0x3b>
+		} else if ((c == '\b' || c == '\x7f') && i > 0) {
+f0101219:	83 f8 08             	cmp    $0x8,%eax
+f010121c:	0f 94 c2             	sete   %dl
+f010121f:	83 f8 7f             	cmp    $0x7f,%eax
+f0101222:	0f 94 c0             	sete   %al
+f0101225:	08 c2                	or     %al,%dl
+f0101227:	74 04                	je     f010122d <readline+0xa5>
+f0101229:	85 f6                	test   %esi,%esi
+f010122b:	7f b4                	jg     f01011e1 <readline+0x59>
+		} else if (c >= ' ' && i < BUFLEN-1) {
+f010122d:	83 fb 1f             	cmp    $0x1f,%ebx
+f0101230:	7e 0e                	jle    f0101240 <readline+0xb8>
+f0101232:	81 fe fe 03 00 00    	cmp    $0x3fe,%esi
+f0101238:	7f 06                	jg     f0101240 <readline+0xb8>
+			if (echoing)
+f010123a:	85 ff                	test   %edi,%edi
+f010123c:	74 c7                	je     f0101205 <readline+0x7d>
+f010123e:	eb b9                	jmp    f01011f9 <readline+0x71>
+		} else if (c == '\n' || c == '\r') {
+f0101240:	83 fb 0a             	cmp    $0xa,%ebx
+f0101243:	74 05                	je     f010124a <readline+0xc2>
+f0101245:	83 fb 0d             	cmp    $0xd,%ebx
+f0101248:	75 c4                	jne    f010120e <readline+0x86>
+			if (echoing)
+f010124a:	85 ff                	test   %edi,%edi
+f010124c:	75 11                	jne    f010125f <readline+0xd7>
+			buf[i] = 0;
+f010124e:	c6 86 40 25 11 f0 00 	movb   $0x0,-0xfeedac0(%esi)
+			return buf;
+f0101255:	b8 40 25 11 f0       	mov    $0xf0112540,%eax
+f010125a:	e9 7a ff ff ff       	jmp    f01011d9 <readline+0x51>
+				cputchar('\n');
+f010125f:	83 ec 0c             	sub    $0xc,%esp
+f0101262:	6a 0a                	push   $0xa
+f0101264:	e8 16 f4 ff ff       	call   f010067f <cputchar>
+f0101269:	83 c4 10             	add    $0x10,%esp
+f010126c:	eb e0                	jmp    f010124e <readline+0xc6>
+
+f010126e <strlen>:
+// Primespipe runs 3x faster this way.
+#define ASM 1
+
+int
+strlen(const char *s)
+{
+f010126e:	f3 0f 1e fb          	endbr32 
+f0101272:	55                   	push   %ebp
+f0101273:	89 e5                	mov    %esp,%ebp
+f0101275:	8b 55 08             	mov    0x8(%ebp),%edx
+	int n;
+
+	for (n = 0; *s != '\0'; s++)
+f0101278:	b8 00 00 00 00       	mov    $0x0,%eax
+f010127d:	80 3c 02 00          	cmpb   $0x0,(%edx,%eax,1)
+f0101281:	74 05                	je     f0101288 <strlen+0x1a>
+		n++;
+f0101283:	83 c0 01             	add    $0x1,%eax
+f0101286:	eb f5                	jmp    f010127d <strlen+0xf>
+	return n;
+}
+f0101288:	5d                   	pop    %ebp
+f0101289:	c3                   	ret    
+
+f010128a <strnlen>:
+
+int
+strnlen(const char *s, size_t size)
+{
+f010128a:	f3 0f 1e fb          	endbr32 
+f010128e:	55                   	push   %ebp
+f010128f:	89 e5                	mov    %esp,%ebp
+f0101291:	8b 4d 08             	mov    0x8(%ebp),%ecx
+f0101294:	8b 55 0c             	mov    0xc(%ebp),%edx
+	int n;
+
+	for (n = 0; size > 0 && *s != '\0'; s++, size--)
+f0101297:	b8 00 00 00 00       	mov    $0x0,%eax
+f010129c:	39 d0                	cmp    %edx,%eax
+f010129e:	74 0d                	je     f01012ad <strnlen+0x23>
+f01012a0:	80 3c 01 00          	cmpb   $0x0,(%ecx,%eax,1)
+f01012a4:	74 05                	je     f01012ab <strnlen+0x21>
+		n++;
+f01012a6:	83 c0 01             	add    $0x1,%eax
+f01012a9:	eb f1                	jmp    f010129c <strnlen+0x12>
+f01012ab:	89 c2                	mov    %eax,%edx
+	return n;
+}
+f01012ad:	89 d0                	mov    %edx,%eax
+f01012af:	5d                   	pop    %ebp
+f01012b0:	c3                   	ret    
+
+f01012b1 <strcpy>:
+
+char *
+strcpy(char *dst, const char *src)
+{
+f01012b1:	f3 0f 1e fb          	endbr32 
+f01012b5:	55                   	push   %ebp
+f01012b6:	89 e5                	mov    %esp,%ebp
+f01012b8:	53                   	push   %ebx
+f01012b9:	8b 4d 08             	mov    0x8(%ebp),%ecx
+f01012bc:	8b 5d 0c             	mov    0xc(%ebp),%ebx
+	char *ret;
+
+	ret = dst;
+	while ((*dst++ = *src++) != '\0')
+f01012bf:	b8 00 00 00 00       	mov    $0x0,%eax
+f01012c4:	0f b6 14 03          	movzbl (%ebx,%eax,1),%edx
+f01012c8:	88 14 01             	mov    %dl,(%ecx,%eax,1)
+f01012cb:	83 c0 01             	add    $0x1,%eax
+f01012ce:	84 d2                	test   %dl,%dl
+f01012d0:	75 f2                	jne    f01012c4 <strcpy+0x13>
+		/* do nothing */;
+	return ret;
+}
+f01012d2:	89 c8                	mov    %ecx,%eax
+f01012d4:	5b                   	pop    %ebx
+f01012d5:	5d                   	pop    %ebp
+f01012d6:	c3                   	ret    
+
+f01012d7 <strcat>:
+
+char *
+strcat(char *dst, const char *src)
+{
+f01012d7:	f3 0f 1e fb          	endbr32 
+f01012db:	55                   	push   %ebp
+f01012dc:	89 e5                	mov    %esp,%ebp
+f01012de:	53                   	push   %ebx
+f01012df:	83 ec 10             	sub    $0x10,%esp
+f01012e2:	8b 5d 08             	mov    0x8(%ebp),%ebx
+	int len = strlen(dst);
+f01012e5:	53                   	push   %ebx
+f01012e6:	e8 83 ff ff ff       	call   f010126e <strlen>
+f01012eb:	83 c4 08             	add    $0x8,%esp
+	strcpy(dst + len, src);
+f01012ee:	ff 75 0c             	pushl  0xc(%ebp)
+f01012f1:	01 d8                	add    %ebx,%eax
+f01012f3:	50                   	push   %eax
+f01012f4:	e8 b8 ff ff ff       	call   f01012b1 <strcpy>
+	return dst;
+}
+f01012f9:	89 d8                	mov    %ebx,%eax
+f01012fb:	8b 5d fc             	mov    -0x4(%ebp),%ebx
+f01012fe:	c9                   	leave  
+f01012ff:	c3                   	ret    
+
+f0101300 <strncpy>:
+
+char *
+strncpy(char *dst, const char *src, size_t size) {
+f0101300:	f3 0f 1e fb          	endbr32 
+f0101304:	55                   	push   %ebp
+f0101305:	89 e5                	mov    %esp,%ebp
+f0101307:	56                   	push   %esi
+f0101308:	53                   	push   %ebx
+f0101309:	8b 75 08             	mov    0x8(%ebp),%esi
+f010130c:	8b 55 0c             	mov    0xc(%ebp),%edx
+f010130f:	89 f3                	mov    %esi,%ebx
+f0101311:	03 5d 10             	add    0x10(%ebp),%ebx
+	size_t i;
+	char *ret;
+
+	ret = dst;
+	for (i = 0; i < size; i++) {
+f0101314:	89 f0                	mov    %esi,%eax
+f0101316:	39 d8                	cmp    %ebx,%eax
+f0101318:	74 11                	je     f010132b <strncpy+0x2b>
+		*dst++ = *src;
+f010131a:	83 c0 01             	add    $0x1,%eax
+f010131d:	0f b6 0a             	movzbl (%edx),%ecx
+f0101320:	88 48 ff             	mov    %cl,-0x1(%eax)
+		// If strlen(src) < size, null-pad 'dst' out to 'size' chars
+		if (*src != '\0')
+			src++;
+f0101323:	80 f9 01             	cmp    $0x1,%cl
+f0101326:	83 da ff             	sbb    $0xffffffff,%edx
+f0101329:	eb eb                	jmp    f0101316 <strncpy+0x16>
+	}
+	return ret;
+}
+f010132b:	89 f0                	mov    %esi,%eax
+f010132d:	5b                   	pop    %ebx
+f010132e:	5e                   	pop    %esi
+f010132f:	5d                   	pop    %ebp
+f0101330:	c3                   	ret    
+
+f0101331 <strlcpy>:
+
+size_t
+strlcpy(char *dst, const char *src, size_t size)
+{
+f0101331:	f3 0f 1e fb          	endbr32 
+f0101335:	55                   	push   %ebp
+f0101336:	89 e5                	mov    %esp,%ebp
+f0101338:	56                   	push   %esi
+f0101339:	53                   	push   %ebx
+f010133a:	8b 75 08             	mov    0x8(%ebp),%esi
+f010133d:	8b 4d 0c             	mov    0xc(%ebp),%ecx
+f0101340:	8b 55 10             	mov    0x10(%ebp),%edx
+f0101343:	89 f0                	mov    %esi,%eax
+	char *dst_in;
+
+	dst_in = dst;
+	if (size > 0) {
+f0101345:	85 d2                	test   %edx,%edx
+f0101347:	74 21                	je     f010136a <strlcpy+0x39>
+f0101349:	8d 44 16 ff          	lea    -0x1(%esi,%edx,1),%eax
+f010134d:	89 f2                	mov    %esi,%edx
+		while (--size > 0 && *src != '\0')
+f010134f:	39 c2                	cmp    %eax,%edx
+f0101351:	74 14                	je     f0101367 <strlcpy+0x36>
+f0101353:	0f b6 19             	movzbl (%ecx),%ebx
+f0101356:	84 db                	test   %bl,%bl
+f0101358:	74 0b                	je     f0101365 <strlcpy+0x34>
+			*dst++ = *src++;
+f010135a:	83 c1 01             	add    $0x1,%ecx
+f010135d:	83 c2 01             	add    $0x1,%edx
+f0101360:	88 5a ff             	mov    %bl,-0x1(%edx)
+f0101363:	eb ea                	jmp    f010134f <strlcpy+0x1e>
+f0101365:	89 d0                	mov    %edx,%eax
+		*dst = '\0';
+f0101367:	c6 00 00             	movb   $0x0,(%eax)
+	}
+	return dst - dst_in;
+f010136a:	29 f0                	sub    %esi,%eax
+}
+f010136c:	5b                   	pop    %ebx
+f010136d:	5e                   	pop    %esi
+f010136e:	5d                   	pop    %ebp
+f010136f:	c3                   	ret    
+
+f0101370 <strcmp>:
+
+int
+strcmp(const char *p, const char *q)
+{
+f0101370:	f3 0f 1e fb          	endbr32 
+f0101374:	55                   	push   %ebp
+f0101375:	89 e5                	mov    %esp,%ebp
+f0101377:	8b 4d 08             	mov    0x8(%ebp),%ecx
+f010137a:	8b 55 0c             	mov    0xc(%ebp),%edx
+	while (*p && *p == *q)
+f010137d:	0f b6 01             	movzbl (%ecx),%eax
+f0101380:	84 c0                	test   %al,%al
+f0101382:	74 0c                	je     f0101390 <strcmp+0x20>
+f0101384:	3a 02                	cmp    (%edx),%al
+f0101386:	75 08                	jne    f0101390 <strcmp+0x20>
+		p++, q++;
+f0101388:	83 c1 01             	add    $0x1,%ecx
+f010138b:	83 c2 01             	add    $0x1,%edx
+f010138e:	eb ed                	jmp    f010137d <strcmp+0xd>
+	return (int) ((unsigned char) *p - (unsigned char) *q);
+f0101390:	0f b6 c0             	movzbl %al,%eax
+f0101393:	0f b6 12             	movzbl (%edx),%edx
+f0101396:	29 d0                	sub    %edx,%eax
+}
+f0101398:	5d                   	pop    %ebp
+f0101399:	c3                   	ret    
+
+f010139a <strncmp>:
+
+int
+strncmp(const char *p, const char *q, size_t n)
+{
+f010139a:	f3 0f 1e fb          	endbr32 
+f010139e:	55                   	push   %ebp
+f010139f:	89 e5                	mov    %esp,%ebp
+f01013a1:	53                   	push   %ebx
+f01013a2:	8b 45 08             	mov    0x8(%ebp),%eax
+f01013a5:	8b 55 0c             	mov    0xc(%ebp),%edx
+f01013a8:	89 c3                	mov    %eax,%ebx
+f01013aa:	03 5d 10             	add    0x10(%ebp),%ebx
+	while (n > 0 && *p && *p == *q)
+f01013ad:	eb 06                	jmp    f01013b5 <strncmp+0x1b>
+		n--, p++, q++;
+f01013af:	83 c0 01             	add    $0x1,%eax
+f01013b2:	83 c2 01             	add    $0x1,%edx
+	while (n > 0 && *p && *p == *q)
+f01013b5:	39 d8                	cmp    %ebx,%eax
+f01013b7:	74 16                	je     f01013cf <strncmp+0x35>
+f01013b9:	0f b6 08             	movzbl (%eax),%ecx
+f01013bc:	84 c9                	test   %cl,%cl
+f01013be:	74 04                	je     f01013c4 <strncmp+0x2a>
+f01013c0:	3a 0a                	cmp    (%edx),%cl
+f01013c2:	74 eb                	je     f01013af <strncmp+0x15>
+	if (n == 0)
+		return 0;
+	else
+		return (int) ((unsigned char) *p - (unsigned char) *q);
+f01013c4:	0f b6 00             	movzbl (%eax),%eax
+f01013c7:	0f b6 12             	movzbl (%edx),%edx
+f01013ca:	29 d0                	sub    %edx,%eax
+}
+f01013cc:	5b                   	pop    %ebx
+f01013cd:	5d                   	pop    %ebp
+f01013ce:	c3                   	ret    
+		return 0;
+f01013cf:	b8 00 00 00 00       	mov    $0x0,%eax
+f01013d4:	eb f6                	jmp    f01013cc <strncmp+0x32>
+
+f01013d6 <strchr>:
+
+// Return a pointer to the first occurrence of 'c' in 's',
+// or a null pointer if the string has no 'c'.
+char *
+strchr(const char *s, char c)
+{
+f01013d6:	f3 0f 1e fb          	endbr32 
+f01013da:	55                   	push   %ebp
+f01013db:	89 e5                	mov    %esp,%ebp
+f01013dd:	8b 45 08             	mov    0x8(%ebp),%eax
+f01013e0:	0f b6 4d 0c          	movzbl 0xc(%ebp),%ecx
+	for (; *s; s++)
+f01013e4:	0f b6 10             	movzbl (%eax),%edx
+f01013e7:	84 d2                	test   %dl,%dl
+f01013e9:	74 09                	je     f01013f4 <strchr+0x1e>
+		if (*s == c)
+f01013eb:	38 ca                	cmp    %cl,%dl
+f01013ed:	74 0a                	je     f01013f9 <strchr+0x23>
+	for (; *s; s++)
+f01013ef:	83 c0 01             	add    $0x1,%eax
+f01013f2:	eb f0                	jmp    f01013e4 <strchr+0xe>
+			return (char *) s;
+	return 0;
+f01013f4:	b8 00 00 00 00       	mov    $0x0,%eax
+}
+f01013f9:	5d                   	pop    %ebp
+f01013fa:	c3                   	ret    
+
+f01013fb <strfind>:
+
+// Return a pointer to the first occurrence of 'c' in 's',
+// or a pointer to the string-ending null character if the string has no 'c'.
+char *
+strfind(const char *s, char c)
+{
+f01013fb:	f3 0f 1e fb          	endbr32 
+f01013ff:	55                   	push   %ebp
+f0101400:	89 e5                	mov    %esp,%ebp
+f0101402:	8b 45 08             	mov    0x8(%ebp),%eax
+f0101405:	0f b6 4d 0c          	movzbl 0xc(%ebp),%ecx
+	for (; *s; s++)
+f0101409:	0f b6 10             	movzbl (%eax),%edx
+		if (*s == c)
+f010140c:	38 ca                	cmp    %cl,%dl
+f010140e:	74 09                	je     f0101419 <strfind+0x1e>
+f0101410:	84 d2                	test   %dl,%dl
+f0101412:	74 05                	je     f0101419 <strfind+0x1e>
+	for (; *s; s++)
+f0101414:	83 c0 01             	add    $0x1,%eax
+f0101417:	eb f0                	jmp    f0101409 <strfind+0xe>
+			break;
+	return (char *) s;
+}
+f0101419:	5d                   	pop    %ebp
+f010141a:	c3                   	ret    
+
+f010141b <memset>:
+
+#if ASM
+void *
+memset(void *v, int c, size_t n)
+{
+f010141b:	f3 0f 1e fb          	endbr32 
+f010141f:	55                   	push   %ebp
+f0101420:	89 e5                	mov    %esp,%ebp
+f0101422:	57                   	push   %edi
+f0101423:	56                   	push   %esi
+f0101424:	53                   	push   %ebx
+f0101425:	8b 7d 08             	mov    0x8(%ebp),%edi
+f0101428:	8b 4d 10             	mov    0x10(%ebp),%ecx
+	char *p;
+
+	if (n == 0)
+f010142b:	85 c9                	test   %ecx,%ecx
+f010142d:	74 31                	je     f0101460 <memset+0x45>
+		return v;
+	if ((int)v%4 == 0 && n%4 == 0) {
+f010142f:	89 f8                	mov    %edi,%eax
+f0101431:	09 c8                	or     %ecx,%eax
+f0101433:	a8 03                	test   $0x3,%al
+f0101435:	75 23                	jne    f010145a <memset+0x3f>
+		c &= 0xFF;
+f0101437:	0f b6 55 0c          	movzbl 0xc(%ebp),%edx
+		c = (c<<24)|(c<<16)|(c<<8)|c;
+f010143b:	89 d3                	mov    %edx,%ebx
+f010143d:	c1 e3 08             	shl    $0x8,%ebx
+f0101440:	89 d0                	mov    %edx,%eax
+f0101442:	c1 e0 18             	shl    $0x18,%eax
+f0101445:	89 d6                	mov    %edx,%esi
+f0101447:	c1 e6 10             	shl    $0x10,%esi
+f010144a:	09 f0                	or     %esi,%eax
+f010144c:	09 c2                	or     %eax,%edx
+f010144e:	09 da                	or     %ebx,%edx
+		asm volatile("cld; rep stosl\n"
+			:: "D" (v), "a" (c), "c" (n/4)
+f0101450:	c1 e9 02             	shr    $0x2,%ecx
+		asm volatile("cld; rep stosl\n"
+f0101453:	89 d0                	mov    %edx,%eax
+f0101455:	fc                   	cld    
+f0101456:	f3 ab                	rep stos %eax,%es:(%edi)
+f0101458:	eb 06                	jmp    f0101460 <memset+0x45>
+			: "cc", "memory");
+	} else
+		asm volatile("cld; rep stosb\n"
+f010145a:	8b 45 0c             	mov    0xc(%ebp),%eax
+f010145d:	fc                   	cld    
+f010145e:	f3 aa                	rep stos %al,%es:(%edi)
+			:: "D" (v), "a" (c), "c" (n)
+			: "cc", "memory");
+	return v;
+}
+f0101460:	89 f8                	mov    %edi,%eax
+f0101462:	5b                   	pop    %ebx
+f0101463:	5e                   	pop    %esi
+f0101464:	5f                   	pop    %edi
+f0101465:	5d                   	pop    %ebp
+f0101466:	c3                   	ret    
+
+f0101467 <memmove>:
+
+void *
+memmove(void *dst, const void *src, size_t n)
+{
+f0101467:	f3 0f 1e fb          	endbr32 
+f010146b:	55                   	push   %ebp
+f010146c:	89 e5                	mov    %esp,%ebp
+f010146e:	57                   	push   %edi
+f010146f:	56                   	push   %esi
+f0101470:	8b 45 08             	mov    0x8(%ebp),%eax
+f0101473:	8b 75 0c             	mov    0xc(%ebp),%esi
+f0101476:	8b 4d 10             	mov    0x10(%ebp),%ecx
+	const char *s;
+	char *d;
+
+	s = src;
+	d = dst;
+	if (s < d && s + n > d) {
+f0101479:	39 c6                	cmp    %eax,%esi
+f010147b:	73 32                	jae    f01014af <memmove+0x48>
+f010147d:	8d 14 0e             	lea    (%esi,%ecx,1),%edx
+f0101480:	39 c2                	cmp    %eax,%edx
+f0101482:	76 2b                	jbe    f01014af <memmove+0x48>
+		s += n;
+		d += n;
+f0101484:	8d 3c 08             	lea    (%eax,%ecx,1),%edi
+		if ((int)s%4 == 0 && (int)d%4 == 0 && n%4 == 0)
+f0101487:	89 fe                	mov    %edi,%esi
+f0101489:	09 ce                	or     %ecx,%esi
+f010148b:	09 d6                	or     %edx,%esi
+f010148d:	f7 c6 03 00 00 00    	test   $0x3,%esi
+f0101493:	75 0e                	jne    f01014a3 <memmove+0x3c>
+			asm volatile("std; rep movsl\n"
+				:: "D" (d-4), "S" (s-4), "c" (n/4) : "cc", "memory");
+f0101495:	83 ef 04             	sub    $0x4,%edi
+f0101498:	8d 72 fc             	lea    -0x4(%edx),%esi
+f010149b:	c1 e9 02             	shr    $0x2,%ecx
+			asm volatile("std; rep movsl\n"
+f010149e:	fd                   	std    
+f010149f:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)
+f01014a1:	eb 09                	jmp    f01014ac <memmove+0x45>
+		else
+			asm volatile("std; rep movsb\n"
+				:: "D" (d-1), "S" (s-1), "c" (n) : "cc", "memory");
+f01014a3:	83 ef 01             	sub    $0x1,%edi
+f01014a6:	8d 72 ff             	lea    -0x1(%edx),%esi
+			asm volatile("std; rep movsb\n"
+f01014a9:	fd                   	std    
+f01014aa:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)
+		// Some versions of GCC rely on DF being clear
+		asm volatile("cld" ::: "cc");
+f01014ac:	fc                   	cld    
+f01014ad:	eb 1a                	jmp    f01014c9 <memmove+0x62>
+	} else {
+		if ((int)s%4 == 0 && (int)d%4 == 0 && n%4 == 0)
+f01014af:	89 c2                	mov    %eax,%edx
+f01014b1:	09 ca                	or     %ecx,%edx
+f01014b3:	09 f2                	or     %esi,%edx
+f01014b5:	f6 c2 03             	test   $0x3,%dl
+f01014b8:	75 0a                	jne    f01014c4 <memmove+0x5d>
+			asm volatile("cld; rep movsl\n"
+				:: "D" (d), "S" (s), "c" (n/4) : "cc", "memory");
+f01014ba:	c1 e9 02             	shr    $0x2,%ecx
+			asm volatile("cld; rep movsl\n"
+f01014bd:	89 c7                	mov    %eax,%edi
+f01014bf:	fc                   	cld    
+f01014c0:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)
+f01014c2:	eb 05                	jmp    f01014c9 <memmove+0x62>
+		else
+			asm volatile("cld; rep movsb\n"
+f01014c4:	89 c7                	mov    %eax,%edi
+f01014c6:	fc                   	cld    
+f01014c7:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)
+				:: "D" (d), "S" (s), "c" (n) : "cc", "memory");
+	}
+	return dst;
+}
+f01014c9:	5e                   	pop    %esi
+f01014ca:	5f                   	pop    %edi
+f01014cb:	5d                   	pop    %ebp
+f01014cc:	c3                   	ret    
+
+f01014cd <memcpy>:
+}
+#endif
+
+void *
+memcpy(void *dst, const void *src, size_t n)
+{
+f01014cd:	f3 0f 1e fb          	endbr32 
+f01014d1:	55                   	push   %ebp
+f01014d2:	89 e5                	mov    %esp,%ebp
+f01014d4:	83 ec 0c             	sub    $0xc,%esp
+	return memmove(dst, src, n);
+f01014d7:	ff 75 10             	pushl  0x10(%ebp)
+f01014da:	ff 75 0c             	pushl  0xc(%ebp)
+f01014dd:	ff 75 08             	pushl  0x8(%ebp)
+f01014e0:	e8 82 ff ff ff       	call   f0101467 <memmove>
+}
+f01014e5:	c9                   	leave  
+f01014e6:	c3                   	ret    
+
+f01014e7 <memcmp>:
+
+int
+memcmp(const void *v1, const void *v2, size_t n)
+{
+f01014e7:	f3 0f 1e fb          	endbr32 
+f01014eb:	55                   	push   %ebp
+f01014ec:	89 e5                	mov    %esp,%ebp
+f01014ee:	56                   	push   %esi
+f01014ef:	53                   	push   %ebx
+f01014f0:	8b 45 08             	mov    0x8(%ebp),%eax
+f01014f3:	8b 55 0c             	mov    0xc(%ebp),%edx
+f01014f6:	89 c6                	mov    %eax,%esi
+f01014f8:	03 75 10             	add    0x10(%ebp),%esi
+	const uint8_t *s1 = (const uint8_t *) v1;
+	const uint8_t *s2 = (const uint8_t *) v2;
+
+	while (n-- > 0) {
+f01014fb:	39 f0                	cmp    %esi,%eax
+f01014fd:	74 1c                	je     f010151b <memcmp+0x34>
+		if (*s1 != *s2)
+f01014ff:	0f b6 08             	movzbl (%eax),%ecx
+f0101502:	0f b6 1a             	movzbl (%edx),%ebx
+f0101505:	38 d9                	cmp    %bl,%cl
+f0101507:	75 08                	jne    f0101511 <memcmp+0x2a>
+			return (int) *s1 - (int) *s2;
+		s1++, s2++;
+f0101509:	83 c0 01             	add    $0x1,%eax
+f010150c:	83 c2 01             	add    $0x1,%edx
+f010150f:	eb ea                	jmp    f01014fb <memcmp+0x14>
+			return (int) *s1 - (int) *s2;
+f0101511:	0f b6 c1             	movzbl %cl,%eax
+f0101514:	0f b6 db             	movzbl %bl,%ebx
+f0101517:	29 d8                	sub    %ebx,%eax
+f0101519:	eb 05                	jmp    f0101520 <memcmp+0x39>
+	}
+
+	return 0;
+f010151b:	b8 00 00 00 00       	mov    $0x0,%eax
+}
+f0101520:	5b                   	pop    %ebx
+f0101521:	5e                   	pop    %esi
+f0101522:	5d                   	pop    %ebp
+f0101523:	c3                   	ret    
+
+f0101524 <memfind>:
+
+void *
+memfind(const void *s, int c, size_t n)
+{
+f0101524:	f3 0f 1e fb          	endbr32 
+f0101528:	55                   	push   %ebp
+f0101529:	89 e5                	mov    %esp,%ebp
+f010152b:	8b 45 08             	mov    0x8(%ebp),%eax
+f010152e:	8b 4d 0c             	mov    0xc(%ebp),%ecx
+	const void *ends = (const char *) s + n;
+f0101531:	89 c2                	mov    %eax,%edx
+f0101533:	03 55 10             	add    0x10(%ebp),%edx
+	for (; s < ends; s++)
+f0101536:	39 d0                	cmp    %edx,%eax
+f0101538:	73 09                	jae    f0101543 <memfind+0x1f>
+		if (*(const unsigned char *) s == (unsigned char) c)
+f010153a:	38 08                	cmp    %cl,(%eax)
+f010153c:	74 05                	je     f0101543 <memfind+0x1f>
+	for (; s < ends; s++)
+f010153e:	83 c0 01             	add    $0x1,%eax
+f0101541:	eb f3                	jmp    f0101536 <memfind+0x12>
+			break;
+	return (void *) s;
+}
+f0101543:	5d                   	pop    %ebp
+f0101544:	c3                   	ret    
+
+f0101545 <strtol>:
+
+long
+strtol(const char *s, char **endptr, int base)
+{
+f0101545:	f3 0f 1e fb          	endbr32 
+f0101549:	55                   	push   %ebp
+f010154a:	89 e5                	mov    %esp,%ebp
+f010154c:	57                   	push   %edi
+f010154d:	56                   	push   %esi
+f010154e:	53                   	push   %ebx
+f010154f:	8b 4d 08             	mov    0x8(%ebp),%ecx
+f0101552:	8b 5d 10             	mov    0x10(%ebp),%ebx
+	int neg = 0;
+	long val = 0;
+
+	// gobble initial whitespace
+	while (*s == ' ' || *s == '\t')
+f0101555:	eb 03                	jmp    f010155a <strtol+0x15>
+		s++;
+f0101557:	83 c1 01             	add    $0x1,%ecx
+	while (*s == ' ' || *s == '\t')
+f010155a:	0f b6 01             	movzbl (%ecx),%eax
+f010155d:	3c 20                	cmp    $0x20,%al
+f010155f:	74 f6                	je     f0101557 <strtol+0x12>
+f0101561:	3c 09                	cmp    $0x9,%al
+f0101563:	74 f2                	je     f0101557 <strtol+0x12>
+
+	// plus/minus sign
+	if (*s == '+')
+f0101565:	3c 2b                	cmp    $0x2b,%al
+f0101567:	74 2a                	je     f0101593 <strtol+0x4e>
+	int neg = 0;
+f0101569:	bf 00 00 00 00       	mov    $0x0,%edi
+		s++;
+	else if (*s == '-')
+f010156e:	3c 2d                	cmp    $0x2d,%al
+f0101570:	74 2b                	je     f010159d <strtol+0x58>
+		s++, neg = 1;
+
+	// hex or octal base prefix
+	if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x'))
+f0101572:	f7 c3 ef ff ff ff    	test   $0xffffffef,%ebx
+f0101578:	75 0f                	jne    f0101589 <strtol+0x44>
+f010157a:	80 39 30             	cmpb   $0x30,(%ecx)
+f010157d:	74 28                	je     f01015a7 <strtol+0x62>
+		s += 2, base = 16;
+	else if (base == 0 && s[0] == '0')
+		s++, base = 8;
+	else if (base == 0)
+		base = 10;
+f010157f:	85 db                	test   %ebx,%ebx
+f0101581:	b8 0a 00 00 00       	mov    $0xa,%eax
+f0101586:	0f 44 d8             	cmove  %eax,%ebx
+f0101589:	b8 00 00 00 00       	mov    $0x0,%eax
+f010158e:	89 5d 10             	mov    %ebx,0x10(%ebp)
+f0101591:	eb 46                	jmp    f01015d9 <strtol+0x94>
+		s++;
+f0101593:	83 c1 01             	add    $0x1,%ecx
+	int neg = 0;
+f0101596:	bf 00 00 00 00       	mov    $0x0,%edi
+f010159b:	eb d5                	jmp    f0101572 <strtol+0x2d>
+		s++, neg = 1;
+f010159d:	83 c1 01             	add    $0x1,%ecx
+f01015a0:	bf 01 00 00 00       	mov    $0x1,%edi
+f01015a5:	eb cb                	jmp    f0101572 <strtol+0x2d>
+	if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x'))
+f01015a7:	80 79 01 78          	cmpb   $0x78,0x1(%ecx)
+f01015ab:	74 0e                	je     f01015bb <strtol+0x76>
+	else if (base == 0 && s[0] == '0')
+f01015ad:	85 db                	test   %ebx,%ebx
+f01015af:	75 d8                	jne    f0101589 <strtol+0x44>
+		s++, base = 8;
+f01015b1:	83 c1 01             	add    $0x1,%ecx
+f01015b4:	bb 08 00 00 00       	mov    $0x8,%ebx
+f01015b9:	eb ce                	jmp    f0101589 <strtol+0x44>
+		s += 2, base = 16;
+f01015bb:	83 c1 02             	add    $0x2,%ecx
+f01015be:	bb 10 00 00 00       	mov    $0x10,%ebx
+f01015c3:	eb c4                	jmp    f0101589 <strtol+0x44>
+	// digits
+	while (1) {
+		int dig;
+
+		if (*s >= '0' && *s <= '9')
+			dig = *s - '0';
+f01015c5:	0f be d2             	movsbl %dl,%edx
+f01015c8:	83 ea 30             	sub    $0x30,%edx
+			dig = *s - 'a' + 10;
+		else if (*s >= 'A' && *s <= 'Z')
+			dig = *s - 'A' + 10;
+		else
+			break;
+		if (dig >= base)
+f01015cb:	3b 55 10             	cmp    0x10(%ebp),%edx
+f01015ce:	7d 3a                	jge    f010160a <strtol+0xc5>
+			break;
+		s++, val = (val * base) + dig;
+f01015d0:	83 c1 01             	add    $0x1,%ecx
+f01015d3:	0f af 45 10          	imul   0x10(%ebp),%eax
+f01015d7:	01 d0                	add    %edx,%eax
+		if (*s >= '0' && *s <= '9')
+f01015d9:	0f b6 11             	movzbl (%ecx),%edx
+f01015dc:	8d 72 d0             	lea    -0x30(%edx),%esi
+f01015df:	89 f3                	mov    %esi,%ebx
+f01015e1:	80 fb 09             	cmp    $0x9,%bl
+f01015e4:	76 df                	jbe    f01015c5 <strtol+0x80>
+		else if (*s >= 'a' && *s <= 'z')
+f01015e6:	8d 72 9f             	lea    -0x61(%edx),%esi
+f01015e9:	89 f3                	mov    %esi,%ebx
+f01015eb:	80 fb 19             	cmp    $0x19,%bl
+f01015ee:	77 08                	ja     f01015f8 <strtol+0xb3>
+			dig = *s - 'a' + 10;
+f01015f0:	0f be d2             	movsbl %dl,%edx
+f01015f3:	83 ea 57             	sub    $0x57,%edx
+f01015f6:	eb d3                	jmp    f01015cb <strtol+0x86>
+		else if (*s >= 'A' && *s <= 'Z')
+f01015f8:	8d 72 bf             	lea    -0x41(%edx),%esi
+f01015fb:	89 f3                	mov    %esi,%ebx
+f01015fd:	80 fb 19             	cmp    $0x19,%bl
+f0101600:	77 08                	ja     f010160a <strtol+0xc5>
+			dig = *s - 'A' + 10;
+f0101602:	0f be d2             	movsbl %dl,%edx
+f0101605:	83 ea 37             	sub    $0x37,%edx
+f0101608:	eb c1                	jmp    f01015cb <strtol+0x86>
+		// we don't properly detect overflow!
+	}
+
+	if (endptr)
+f010160a:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)
+f010160e:	74 05                	je     f0101615 <strtol+0xd0>
+		*endptr = (char *) s;
+f0101610:	8b 75 0c             	mov    0xc(%ebp),%esi
+f0101613:	89 0e                	mov    %ecx,(%esi)
+	return (neg ? -val : val);
+f0101615:	89 c2                	mov    %eax,%edx
+f0101617:	f7 da                	neg    %edx
+f0101619:	85 ff                	test   %edi,%edi
+f010161b:	0f 45 c2             	cmovne %edx,%eax
+}
+f010161e:	5b                   	pop    %ebx
+f010161f:	5e                   	pop    %esi
+f0101620:	5f                   	pop    %edi
+f0101621:	5d                   	pop    %ebp
+f0101622:	c3                   	ret    
+f0101623:	66 90                	xchg   %ax,%ax
+f0101625:	66 90                	xchg   %ax,%ax
+f0101627:	66 90                	xchg   %ax,%ax
+f0101629:	66 90                	xchg   %ax,%ax
+f010162b:	66 90                	xchg   %ax,%ax
+f010162d:	66 90                	xchg   %ax,%ax
+f010162f:	90                   	nop
+
+f0101630 <__udivdi3>:
+f0101630:	f3 0f 1e fb          	endbr32 
+f0101634:	55                   	push   %ebp
+f0101635:	57                   	push   %edi
+f0101636:	56                   	push   %esi
+f0101637:	53                   	push   %ebx
+f0101638:	83 ec 1c             	sub    $0x1c,%esp
+f010163b:	8b 54 24 3c          	mov    0x3c(%esp),%edx
+f010163f:	8b 6c 24 30          	mov    0x30(%esp),%ebp
+f0101643:	8b 74 24 34          	mov    0x34(%esp),%esi
+f0101647:	8b 5c 24 38          	mov    0x38(%esp),%ebx
+f010164b:	85 d2                	test   %edx,%edx
+f010164d:	75 19                	jne    f0101668 <__udivdi3+0x38>
+f010164f:	39 f3                	cmp    %esi,%ebx
+f0101651:	76 4d                	jbe    f01016a0 <__udivdi3+0x70>
+f0101653:	31 ff                	xor    %edi,%edi
+f0101655:	89 e8                	mov    %ebp,%eax
+f0101657:	89 f2                	mov    %esi,%edx
+f0101659:	f7 f3                	div    %ebx
+f010165b:	89 fa                	mov    %edi,%edx
+f010165d:	83 c4 1c             	add    $0x1c,%esp
+f0101660:	5b                   	pop    %ebx
+f0101661:	5e                   	pop    %esi
+f0101662:	5f                   	pop    %edi
+f0101663:	5d                   	pop    %ebp
+f0101664:	c3                   	ret    
+f0101665:	8d 76 00             	lea    0x0(%esi),%esi
+f0101668:	39 f2                	cmp    %esi,%edx
+f010166a:	76 14                	jbe    f0101680 <__udivdi3+0x50>
+f010166c:	31 ff                	xor    %edi,%edi
+f010166e:	31 c0                	xor    %eax,%eax
+f0101670:	89 fa                	mov    %edi,%edx
+f0101672:	83 c4 1c             	add    $0x1c,%esp
+f0101675:	5b                   	pop    %ebx
+f0101676:	5e                   	pop    %esi
+f0101677:	5f                   	pop    %edi
+f0101678:	5d                   	pop    %ebp
+f0101679:	c3                   	ret    
+f010167a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
+f0101680:	0f bd fa             	bsr    %edx,%edi
+f0101683:	83 f7 1f             	xor    $0x1f,%edi
+f0101686:	75 48                	jne    f01016d0 <__udivdi3+0xa0>
+f0101688:	39 f2                	cmp    %esi,%edx
+f010168a:	72 06                	jb     f0101692 <__udivdi3+0x62>
+f010168c:	31 c0                	xor    %eax,%eax
+f010168e:	39 eb                	cmp    %ebp,%ebx
+f0101690:	77 de                	ja     f0101670 <__udivdi3+0x40>
+f0101692:	b8 01 00 00 00       	mov    $0x1,%eax
+f0101697:	eb d7                	jmp    f0101670 <__udivdi3+0x40>
+f0101699:	8d b4 26 00 00 00 00 	lea    0x0(%esi,%eiz,1),%esi
+f01016a0:	89 d9                	mov    %ebx,%ecx
+f01016a2:	85 db                	test   %ebx,%ebx
+f01016a4:	75 0b                	jne    f01016b1 <__udivdi3+0x81>
+f01016a6:	b8 01 00 00 00       	mov    $0x1,%eax
+f01016ab:	31 d2                	xor    %edx,%edx
+f01016ad:	f7 f3                	div    %ebx
+f01016af:	89 c1                	mov    %eax,%ecx
+f01016b1:	31 d2                	xor    %edx,%edx
+f01016b3:	89 f0                	mov    %esi,%eax
+f01016b5:	f7 f1                	div    %ecx
+f01016b7:	89 c6                	mov    %eax,%esi
+f01016b9:	89 e8                	mov    %ebp,%eax
+f01016bb:	89 f7                	mov    %esi,%edi
+f01016bd:	f7 f1                	div    %ecx
+f01016bf:	89 fa                	mov    %edi,%edx
+f01016c1:	83 c4 1c             	add    $0x1c,%esp
+f01016c4:	5b                   	pop    %ebx
+f01016c5:	5e                   	pop    %esi
+f01016c6:	5f                   	pop    %edi
+f01016c7:	5d                   	pop    %ebp
+f01016c8:	c3                   	ret    
+f01016c9:	8d b4 26 00 00 00 00 	lea    0x0(%esi,%eiz,1),%esi
+f01016d0:	89 f9                	mov    %edi,%ecx
+f01016d2:	b8 20 00 00 00       	mov    $0x20,%eax
+f01016d7:	29 f8                	sub    %edi,%eax
+f01016d9:	d3 e2                	shl    %cl,%edx
+f01016db:	89 54 24 08          	mov    %edx,0x8(%esp)
+f01016df:	89 c1                	mov    %eax,%ecx
+f01016e1:	89 da                	mov    %ebx,%edx
+f01016e3:	d3 ea                	shr    %cl,%edx
+f01016e5:	8b 4c 24 08          	mov    0x8(%esp),%ecx
+f01016e9:	09 d1                	or     %edx,%ecx
+f01016eb:	89 f2                	mov    %esi,%edx
+f01016ed:	89 4c 24 08          	mov    %ecx,0x8(%esp)
+f01016f1:	89 f9                	mov    %edi,%ecx
+f01016f3:	d3 e3                	shl    %cl,%ebx
+f01016f5:	89 c1                	mov    %eax,%ecx
+f01016f7:	d3 ea                	shr    %cl,%edx
+f01016f9:	89 f9                	mov    %edi,%ecx
+f01016fb:	89 5c 24 0c          	mov    %ebx,0xc(%esp)
+f01016ff:	89 eb                	mov    %ebp,%ebx
+f0101701:	d3 e6                	shl    %cl,%esi
+f0101703:	89 c1                	mov    %eax,%ecx
+f0101705:	d3 eb                	shr    %cl,%ebx
+f0101707:	09 de                	or     %ebx,%esi
+f0101709:	89 f0                	mov    %esi,%eax
+f010170b:	f7 74 24 08          	divl   0x8(%esp)
+f010170f:	89 d6                	mov    %edx,%esi
+f0101711:	89 c3                	mov    %eax,%ebx
+f0101713:	f7 64 24 0c          	mull   0xc(%esp)
+f0101717:	39 d6                	cmp    %edx,%esi
+f0101719:	72 15                	jb     f0101730 <__udivdi3+0x100>
+f010171b:	89 f9                	mov    %edi,%ecx
+f010171d:	d3 e5                	shl    %cl,%ebp
+f010171f:	39 c5                	cmp    %eax,%ebp
+f0101721:	73 04                	jae    f0101727 <__udivdi3+0xf7>
+f0101723:	39 d6                	cmp    %edx,%esi
+f0101725:	74 09                	je     f0101730 <__udivdi3+0x100>
+f0101727:	89 d8                	mov    %ebx,%eax
+f0101729:	31 ff                	xor    %edi,%edi
+f010172b:	e9 40 ff ff ff       	jmp    f0101670 <__udivdi3+0x40>
+f0101730:	8d 43 ff             	lea    -0x1(%ebx),%eax
+f0101733:	31 ff                	xor    %edi,%edi
+f0101735:	e9 36 ff ff ff       	jmp    f0101670 <__udivdi3+0x40>
+f010173a:	66 90                	xchg   %ax,%ax
+f010173c:	66 90                	xchg   %ax,%ax
+f010173e:	66 90                	xchg   %ax,%ax
+
+f0101740 <__umoddi3>:
+f0101740:	f3 0f 1e fb          	endbr32 
+f0101744:	55                   	push   %ebp
+f0101745:	57                   	push   %edi
+f0101746:	56                   	push   %esi
+f0101747:	53                   	push   %ebx
+f0101748:	83 ec 1c             	sub    $0x1c,%esp
+f010174b:	8b 44 24 3c          	mov    0x3c(%esp),%eax
+f010174f:	8b 74 24 30          	mov    0x30(%esp),%esi
+f0101753:	8b 5c 24 34          	mov    0x34(%esp),%ebx
+f0101757:	8b 7c 24 38          	mov    0x38(%esp),%edi
+f010175b:	85 c0                	test   %eax,%eax
+f010175d:	75 19                	jne    f0101778 <__umoddi3+0x38>
+f010175f:	39 df                	cmp    %ebx,%edi
+f0101761:	76 5d                	jbe    f01017c0 <__umoddi3+0x80>
+f0101763:	89 f0                	mov    %esi,%eax
+f0101765:	89 da                	mov    %ebx,%edx
+f0101767:	f7 f7                	div    %edi
+f0101769:	89 d0                	mov    %edx,%eax
+f010176b:	31 d2                	xor    %edx,%edx
+f010176d:	83 c4 1c             	add    $0x1c,%esp
+f0101770:	5b                   	pop    %ebx
+f0101771:	5e                   	pop    %esi
+f0101772:	5f                   	pop    %edi
+f0101773:	5d                   	pop    %ebp
+f0101774:	c3                   	ret    
+f0101775:	8d 76 00             	lea    0x0(%esi),%esi
+f0101778:	89 f2                	mov    %esi,%edx
+f010177a:	39 d8                	cmp    %ebx,%eax
+f010177c:	76 12                	jbe    f0101790 <__umoddi3+0x50>
+f010177e:	89 f0                	mov    %esi,%eax
+f0101780:	89 da                	mov    %ebx,%edx
+f0101782:	83 c4 1c             	add    $0x1c,%esp
+f0101785:	5b                   	pop    %ebx
+f0101786:	5e                   	pop    %esi
+f0101787:	5f                   	pop    %edi
+f0101788:	5d                   	pop    %ebp
+f0101789:	c3                   	ret    
+f010178a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
+f0101790:	0f bd e8             	bsr    %eax,%ebp
+f0101793:	83 f5 1f             	xor    $0x1f,%ebp
+f0101796:	75 50                	jne    f01017e8 <__umoddi3+0xa8>
+f0101798:	39 d8                	cmp    %ebx,%eax
+f010179a:	0f 82 e0 00 00 00    	jb     f0101880 <__umoddi3+0x140>
+f01017a0:	89 d9                	mov    %ebx,%ecx
+f01017a2:	39 f7                	cmp    %esi,%edi
+f01017a4:	0f 86 d6 00 00 00    	jbe    f0101880 <__umoddi3+0x140>
+f01017aa:	89 d0                	mov    %edx,%eax
+f01017ac:	89 ca                	mov    %ecx,%edx
+f01017ae:	83 c4 1c             	add    $0x1c,%esp
+f01017b1:	5b                   	pop    %ebx
+f01017b2:	5e                   	pop    %esi
+f01017b3:	5f                   	pop    %edi
+f01017b4:	5d                   	pop    %ebp
+f01017b5:	c3                   	ret    
+f01017b6:	8d b4 26 00 00 00 00 	lea    0x0(%esi,%eiz,1),%esi
+f01017bd:	8d 76 00             	lea    0x0(%esi),%esi
+f01017c0:	89 fd                	mov    %edi,%ebp
+f01017c2:	85 ff                	test   %edi,%edi
+f01017c4:	75 0b                	jne    f01017d1 <__umoddi3+0x91>
+f01017c6:	b8 01 00 00 00       	mov    $0x1,%eax
+f01017cb:	31 d2                	xor    %edx,%edx
+f01017cd:	f7 f7                	div    %edi
+f01017cf:	89 c5                	mov    %eax,%ebp
+f01017d1:	89 d8                	mov    %ebx,%eax
+f01017d3:	31 d2                	xor    %edx,%edx
+f01017d5:	f7 f5                	div    %ebp
+f01017d7:	89 f0                	mov    %esi,%eax
+f01017d9:	f7 f5                	div    %ebp
+f01017db:	89 d0                	mov    %edx,%eax
+f01017dd:	31 d2                	xor    %edx,%edx
+f01017df:	eb 8c                	jmp    f010176d <__umoddi3+0x2d>
+f01017e1:	8d b4 26 00 00 00 00 	lea    0x0(%esi,%eiz,1),%esi
+f01017e8:	89 e9                	mov    %ebp,%ecx
+f01017ea:	ba 20 00 00 00       	mov    $0x20,%edx
+f01017ef:	29 ea                	sub    %ebp,%edx
+f01017f1:	d3 e0                	shl    %cl,%eax
+f01017f3:	89 44 24 08          	mov    %eax,0x8(%esp)
+f01017f7:	89 d1                	mov    %edx,%ecx
+f01017f9:	89 f8                	mov    %edi,%eax
+f01017fb:	d3 e8                	shr    %cl,%eax
+f01017fd:	8b 4c 24 08          	mov    0x8(%esp),%ecx
+f0101801:	89 54 24 04          	mov    %edx,0x4(%esp)
+f0101805:	8b 54 24 04          	mov    0x4(%esp),%edx
+f0101809:	09 c1                	or     %eax,%ecx
+f010180b:	89 d8                	mov    %ebx,%eax
+f010180d:	89 4c 24 08          	mov    %ecx,0x8(%esp)
+f0101811:	89 e9                	mov    %ebp,%ecx
+f0101813:	d3 e7                	shl    %cl,%edi
+f0101815:	89 d1                	mov    %edx,%ecx
+f0101817:	d3 e8                	shr    %cl,%eax
+f0101819:	89 e9                	mov    %ebp,%ecx
+f010181b:	89 7c 24 0c          	mov    %edi,0xc(%esp)
+f010181f:	d3 e3                	shl    %cl,%ebx
+f0101821:	89 c7                	mov    %eax,%edi
+f0101823:	89 d1                	mov    %edx,%ecx
+f0101825:	89 f0                	mov    %esi,%eax
+f0101827:	d3 e8                	shr    %cl,%eax
+f0101829:	89 e9                	mov    %ebp,%ecx
+f010182b:	89 fa                	mov    %edi,%edx
+f010182d:	d3 e6                	shl    %cl,%esi
+f010182f:	09 d8                	or     %ebx,%eax
+f0101831:	f7 74 24 08          	divl   0x8(%esp)
+f0101835:	89 d1                	mov    %edx,%ecx
+f0101837:	89 f3                	mov    %esi,%ebx
+f0101839:	f7 64 24 0c          	mull   0xc(%esp)
+f010183d:	89 c6                	mov    %eax,%esi
+f010183f:	89 d7                	mov    %edx,%edi
+f0101841:	39 d1                	cmp    %edx,%ecx
+f0101843:	72 06                	jb     f010184b <__umoddi3+0x10b>
+f0101845:	75 10                	jne    f0101857 <__umoddi3+0x117>
+f0101847:	39 c3                	cmp    %eax,%ebx
+f0101849:	73 0c                	jae    f0101857 <__umoddi3+0x117>
+f010184b:	2b 44 24 0c          	sub    0xc(%esp),%eax
+f010184f:	1b 54 24 08          	sbb    0x8(%esp),%edx
+f0101853:	89 d7                	mov    %edx,%edi
+f0101855:	89 c6                	mov    %eax,%esi
+f0101857:	89 ca                	mov    %ecx,%edx
+f0101859:	0f b6 4c 24 04       	movzbl 0x4(%esp),%ecx
+f010185e:	29 f3                	sub    %esi,%ebx
+f0101860:	19 fa                	sbb    %edi,%edx
+f0101862:	89 d0                	mov    %edx,%eax
+f0101864:	d3 e0                	shl    %cl,%eax
+f0101866:	89 e9                	mov    %ebp,%ecx
+f0101868:	d3 eb                	shr    %cl,%ebx
+f010186a:	d3 ea                	shr    %cl,%edx
+f010186c:	09 d8                	or     %ebx,%eax
+f010186e:	83 c4 1c             	add    $0x1c,%esp
+f0101871:	5b                   	pop    %ebx
+f0101872:	5e                   	pop    %esi
+f0101873:	5f                   	pop    %edi
+f0101874:	5d                   	pop    %ebp
+f0101875:	c3                   	ret    
+f0101876:	8d b4 26 00 00 00 00 	lea    0x0(%esi,%eiz,1),%esi
+f010187d:	8d 76 00             	lea    0x0(%esi),%esi
+f0101880:	29 fe                	sub    %edi,%esi
+f0101882:	19 c3                	sbb    %eax,%ebx
+f0101884:	89 f2                	mov    %esi,%edx
+f0101886:	89 d9                	mov    %ebx,%ecx
+f0101888:	e9 1d ff ff ff       	jmp    f01017aa <__umoddi3+0x6a>
diff --git a/obj/kern/kernel.img b/obj/kern/kernel.img
new file mode 100644
index 0000000..8cfc54c
Binary files /dev/null and b/obj/kern/kernel.img differ
diff --git a/obj/kern/kernel.sym b/obj/kern/kernel.sym
new file mode 100644
index 0000000..64b04ef
--- /dev/null
+++ b/obj/kern/kernel.sym
@@ -0,0 +1,80 @@
+0010000c T _start
+f010000c T entry
+f010002f t relocated
+f010003e t spin
+f0100040 T test_backtrace
+f0100098 T i386_init
+f01000ee T _panic
+f010014b T _warn
+f0100189 t serial_proc_data
+f01001a7 t cons_intr
+f01001e6 t kbd_proc_data
+f01002ff t cons_putc
+f01004f1 T serial_intr
+f0100511 T kbd_intr
+f0100527 T cons_getc
+f010056d T cons_init
+f010067f T cputchar
+f0100693 T getchar
+f01006a8 T iscons
+f01006b2 T mon_help
+f01006ee T mon_kerninfo
+f0100792 T mon_backtrace
+f010079c T monitor
+f01008e6 t putch
+f01008fd T vcprintf
+f0100927 T cprintf
+f010093f t stab_binsearch
+f0100a34 T debuginfo_eip
+f0100c0a t printnum
+f0100cb3 t sprintputch
+f0100cd4 T printfmt
+f0100cf5 T vprintfmt
+f0101118 T vsnprintf
+f010116a T snprintf
+f0101188 T readline
+f010126e T strlen
+f010128a T strnlen
+f01012b1 T strcpy
+f01012d7 T strcat
+f0101300 T strncpy
+f0101331 T strlcpy
+f0101370 T strcmp
+f010139a T strncmp
+f01013d6 T strchr
+f01013fb T strfind
+f010141b T memset
+f0101467 T memmove
+f01014cd T memcpy
+f01014e7 T memcmp
+f0101524 T memfind
+f0101545 T strtol
+f0101630 T __udivdi3
+f0101740 T __umoddi3
+f010188d T etext
+f0101960 r charcode
+f0101980 r togglecode
+f0101a80 r shiftcode
+f0101d64 r commands
+f0101f88 r error_string
+f0101fb4 R __STAB_BEGIN__
+f010622c R __STAB_END__
+f010622d R __STABSTR_BEGIN__
+f0107bd7 R __STABSTR_END__
+f0108000 D bootstack
+f0110000 D bootstacktop
+f0110000 D entry_pgdir
+f0111000 D entry_pgtable
+f0112000 d ctlmap
+f0112100 d shiftmap
+f0112200 d normalmap
+f0112300 B edata
+f0112300 b shift.1385
+f0112320 b cons
+f0112528 b crt_pos
+f011252c b crt_buf
+f0112530 b addr_6845
+f0112534 b serial_exists
+f0112540 b buf
+f0112940 B end
+f0112944 B panicstr
diff --git a/obj/kern/monitor.o b/obj/kern/monitor.o
new file mode 100644
index 0000000..d62b357
Binary files /dev/null and b/obj/kern/monitor.o differ
diff --git a/obj/kern/printf.o b/obj/kern/printf.o
new file mode 100644
index 0000000..a45b0f7
Binary files /dev/null and b/obj/kern/printf.o differ
diff --git a/obj/kern/printfmt.o b/obj/kern/printfmt.o
new file mode 100644
index 0000000..d3239f5
Binary files /dev/null and b/obj/kern/printfmt.o differ
diff --git a/obj/kern/readline.o b/obj/kern/readline.o
new file mode 100644
index 0000000..d63ad24
Binary files /dev/null and b/obj/kern/readline.o differ
diff --git a/obj/kern/string.o b/obj/kern/string.o
new file mode 100644
index 0000000..8e88b91
Binary files /dev/null and b/obj/kern/string.o differ
diff --git a/user/sendpage.c b/user/sendpage.c
new file mode 100644
index 0000000..1adfe94
--- /dev/null
+++ b/user/sendpage.c
@@ -0,0 +1,39 @@
+// Test Conversation between parent and child environment
+// Contributed by Varun Agrawal at Stony Brook
+
+#include <inc/lib.h>
+
+const char *str1 = "hello child environment! how are you?";
+const char *str2 = "hello parent environment! I'm good.";
+
+#define TEMP_ADDR	((char*)0xa00000)
+#define TEMP_ADDR_CHILD	((char*)0xb00000)
+
+void
+umain(int argc, char **argv)
+{
+	envid_t who;
+
+	if ((who = fork()) == 0) {
+		// Child
+		ipc_recv(&who, TEMP_ADDR_CHILD, 0);
+		cprintf("%x got message: %s\n", who, TEMP_ADDR_CHILD);
+		if (strncmp(TEMP_ADDR_CHILD, str1, strlen(str1)) == 0)
+			cprintf("child received correct message\n");
+
+		memcpy(TEMP_ADDR_CHILD, str2, strlen(str2) + 1);
+		ipc_send(who, 0, TEMP_ADDR_CHILD, PTE_P | PTE_W | PTE_U);
+		return;
+	}
+
+	// Parent
+	sys_page_alloc(thisenv->env_id, TEMP_ADDR, PTE_P | PTE_W | PTE_U);
+	memcpy(TEMP_ADDR, str1, strlen(str1) + 1);
+	ipc_send(who, 0, TEMP_ADDR, PTE_P | PTE_W | PTE_U);
+
+	ipc_recv(&who, TEMP_ADDR, 0);
+	cprintf("%x got message: %s\n", who, TEMP_ADDR);
+	if (strncmp(TEMP_ADDR, str2, strlen(str2)) == 0)
+		cprintf("parent received correct message\n");
+	return;
+}