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>