From 1b040423c3d9348545c9cd7b10fa38d4a16b12ec Mon Sep 17 00:00:00 2001
From: iDunnoDev <me@idunnodev.co.uk>
Date: Tue, 22 Nov 2022 00:38:22 +0000
Subject: [PATCH] Fixed memory lea issue in stage 4 Added Stage 5 polygon and
 array functions

---
 stage4/bootasm2.S         |    7 +-
 stage4/bootasm2.o         |  Bin 4808 -> 4808 bytes
 stage4/bootblock2         |  Bin 1091 -> 1088 bytes
 stage4/bootblock2.o       |  Bin 4372 -> 4368 bytes
 stage4/xv6.img            |    2 +-
 stage5/.vscode/tasks.json |   19 +
 stage5/Makefile           |  102 ++++
 stage5/bootasm.S          |  101 ++++
 stage5/bootasm.d          |    1 +
 stage5/bootasm.o          |  Bin 0 -> 2032 bytes
 stage5/bootasm2.S         | 1138 +++++++++++++++++++++++++++++++++++++
 stage5/bootasm2.d         |    1 +
 stage5/bootasm2.o         |  Bin 0 -> 6912 bytes
 stage5/bootblock          |  Bin 0 -> 512 bytes
 stage5/bootblock.o        |  Bin 0 -> 1644 bytes
 stage5/bootblock2         |  Bin 0 -> 1850 bytes
 stage5/bootblock2.o       |  Bin 0 -> 6304 bytes
 stage5/sign.pl            |   19 +
 stage5/xv6.img            |    3 +
 19 files changed, 1388 insertions(+), 5 deletions(-)
 create mode 100644 stage5/.vscode/tasks.json
 create mode 100644 stage5/Makefile
 create mode 100644 stage5/bootasm.S
 create mode 100644 stage5/bootasm.d
 create mode 100644 stage5/bootasm.o
 create mode 100644 stage5/bootasm2.S
 create mode 100644 stage5/bootasm2.d
 create mode 100644 stage5/bootasm2.o
 create mode 100644 stage5/bootblock
 create mode 100644 stage5/bootblock.o
 create mode 100644 stage5/bootblock2
 create mode 100644 stage5/bootblock2.o
 create mode 100644 stage5/sign.pl
 create mode 100644 stage5/xv6.img

diff --git a/stage4/bootasm2.S b/stage4/bootasm2.S
index 6d15cf7..ebd077c 100644
--- a/stage4/bootasm2.S
+++ b/stage4/bootasm2.S
@@ -275,14 +275,14 @@ cons_filled_rect_check_x_dir:
     cmpw    $0, %ax
     jge     cons_filled_rect_check_y_dir
     add     %ax, rectx(%bp)
-    neg     rectwidth(%bp)
+    negw    rectwidth(%bp)
 
 cons_filled_rect_check_y_dir:
     movw    rectheight(%bp), %ax            # Check if the user has entered a negative height value and swap the direction to a pos
     cmpw    $0, %ax
     jge     cons_filled_rect_check_x_zero
     add     %ax, recty(%bp)
-    neg     rectheight(%bp)    
+    negw    rectheight(%bp)    
 
 cons_filled_rect_check_x_zero:
     movw    rectx(%bp), %ax                 # Check if the x value is a negative value, set it to 0 and figure out the offset so we
@@ -344,8 +344,7 @@ cons_filled_rect_setup:
     movw    (screen_width), %ax          # Set ax to 320 so that we can multiply this by y   
     mul     %dx                          # does the (y * 320) part of our math            
     add     rectx(%bp), %ax              # Add the value of x to register ax
-    movw    %ax, %si
-    lea     %es:(%si), %bx      # Load the memory address into the bx register
+    movw    %ax, %bx                     # Load the memory offset address into the bx register    
     
     movw    rectheight(%bp), %si    # Set the counter to our height which should be the number of lines to draw to
 
diff --git a/stage4/bootasm2.o b/stage4/bootasm2.o
index 6c43a6435027469cb00e4cd038b85d8f9db49974..3410ea91d011841cf94d64881a216bccd4effe16 100644
GIT binary patch
delta 751
zcmYk0OK1~O6o&8VOkQIj35JG>=7DWWz)~p~368M@5)h>dwSvJ?3azF$VrU2<#WJ(V
zst$<dir~(!L|sX=3k7M-CQAju3PPc7E>xtb)Fw<4&m=a?g?sqE|D5}%3{{36o`Dmu
z!a?YlMRl-PCCk2Z{ZUaJDAvfbdrf9pxX~?(ku7ymNZ2*6%)Wp>9yNlvkdQR5fr=}%
z6-r1&#ZHvbq9PF`^o~4zP}Z(n*JSbUj*t*n%35C165T7?+Js&I{X*-N*@Z53>VBh{
zmzw$gX8wRHZT{2D*Lb$W2mDr>e>U^Kc(TKLe4@=ij6BxiJsxI9g}4|H`98ZTcx6wc
zShmnUYN3V6tK8Ap*)hEPzgO!N=t(+4-Kocf@7Ad`^_pPMomwUQ8(SA5>IWT9C+Py6
zp-KKmr(LNEX?c=AL!)yzN(<O~qEiQzQemJHmAIxOzb7rl!td#{2mLVQY2#WPY-M~}
z-)+P)nVkP}W_E5q>z~Zc-k$f5`R`=dUC{xyQbF_poGz_eVgMWLvvqKQ;5v@G%K##_
zs!_&Sk1Y-U(vockKxSX<K8UiaJp;XL!7-!O;BXSiDS?n<?eiD{IgcJR`8D*2$<ye%
z$rbco-0cPA5whFl&yfS2p8;7H$QTKl1~!q;n*1a3l*zv%`$|jFOVMG&cis5+Kxw3J
s6kwc9J1;?weR6u(hSS-iVM`7lJHqPNQQ1Y;FuY}pt}C!z+H~3AA8#+}EC2ui

delta 751
zcmYk0Ur19?9LLXZ_wL_i<_60V*u3Oa28ysquvV8T4a2CwvK+*al;&A5k~JsE_OOSN
zi&32LIiZ*8sc!TVSTYD7?J0c<=F5R1B*RqhcKh8e$31X<d_Ldb@BCTsTJL&#2IRK`
z-O#3p#Zc*hEOeY}i;2Y(r9-mdUs2dBOn4M=aI=^d;x09)ux}ub#LQqsh)ZhF#DXup
z8IDV(f{PR)rGi8Xy&uVoCuMcqv7(57D?(gc{L;PDuI3~)?pge<UUBKWuhnA;i`t4e
z9@UJTWaRdY+&+KU;6Fz0kY}2_&+jz&my!F;Z#H>{k2d(HnJZ1+;is8bxG081zRM<r
zVANkLmF={Z+G&358h6wx71KTceXmM^cG5oTPc0M9tJINtPq61tJtKUJX~JOfla8ko
zbcQBrg1^(LEwxVSp5QOh=oF69Joc7#>ZVd^0H{PI{#Zv|C3VHZ^Ez!oKMHxuycP%R
z8BgdxYD1Y!R=%8>oSL4M$Fh@mr{#!zFT>KJ8(i80F#xvy3)+%>2%yY19HHawgb*8U
zLd1GC%P?zkrlC`tcP0T8w&m)87&~xfz{h6X$zm0bCV}({gq&=g#}LSQ^svRRqem^C
zMmH>8K=<KpEFjO30~UXU9BTdy$OnN$NZ2y4hJ4oI8_2gTzKwiJo0r~*ZVBJ@<KIJC
uUu!?WFuUy?g*o=s8(^Qk-a7Tz=kPHPt750bF8O+3mEHGUg>7xk=Y)UcyX#^A

diff --git a/stage4/bootblock2 b/stage4/bootblock2
index dda25ec4b9fcbc16d8f1871a68df3e921a9ae2d8..8f6d29a494552108912711425c0721f85dba3aee 100644
GIT binary patch
delta 441
zcmX|(Jxjw-6ozk-wxkz75Q@^liXVs>#7!uM4ni{)K@^SHE>hxgs$dYT37Dw{1W6Fw
z>?F7eIu%6BBKQY72tubT77>-&mbCGv)h>tUdCz-}!{77l>*zH*%?yjSK4mmeer#bl
zVe3(&iSm)6XeF3+U9{t6J;zDB8S_yK3T1(c6e=MUFCXGUIwUwk8o$v(!tW+I33pK&
z^1Im3c%;o48b+E>LKi2Fxf&{p_D_YA0tLrZu_^TxUd$BleqEUZqRl*|_Ntk*yuPtk
zs9I4rw{qO}RP3oWPpuQJ%io^bB)dJXlWdpYJ@u2wJ^mo6E?510vBw`|-g;q^fpMGE
ztQjsQj<gLY2!jxW{pBSRZdWS4_x*XJ1q@8WEJTzuMBZ8uQf?64MU+!So~<J;o_%oX
zwG7*k0h!#oz$%ZZ<1)FV23xcW`*e5iLKv_z&j1EYOqcQ<>L?xLz=eM5{~_7&-_l|y
KBb(NEVB!~m8^@vm

delta 466
zcmYj}O(+Cm7=XW-wbS_Wn@uSpq_#Mq)TT@hCZ(i=j9LfMcrPwYTh`2B4r~*pnf6RM
zIUxtyLTyROeU(ysdPNfQ*VysRE}P5O^Stl#y=P)t<nNmH`8KXra*S5<lf)Z)Yx^Ce
z&io?r(6(gvag&DRL^8%=Ko+eAAN6236J{a{DMBKd6`F_&;dD4k?^)3Aw}Szh7ErJD
zTWabe(Ys8Y61_b|wl>n%xUelb@7aJ{k~nW$ueUU6$z_RKYglw&cC8A@;Vy@l9;Tzp
z<dj{*FOIF|JdJwVo2Px?a)Dnx?F$!*{DCtCe)P0woG9`W4i)&ppG!r4!fyM9ABeU(
z_~IUty_&14&a<N=NmY_#ftcwaltB<;qazr~`BwRBLN1&AzkT}#4qBiCLTZvAeuJPM
z64r*)O@i095s1v4y6m?C^Dqqx9=O1(7bNcr?l6N{mO_l}k}i}2ReLy~Kyl4wd_wZd
X9*ntA&irqPs(+S+`57v9LrL=w{`Jv)

diff --git a/stage4/bootblock2.o b/stage4/bootblock2.o
index ad388716abd0fff56c0429e612a62d944b58fa7f..13fe6b556ee82dbad6c2e279fd4564d38756b6f5 100644
GIT binary patch
delta 812
zcmYk)Ur19?90%}oyx0A?+Pvn_igI@@6dxif&_)*-f}@9!K$IHDSZLi&(U{0ZXl%ru
z)&<!-m%s?jry%elW=}z6d+8y1s|E?d9^!-{X5pW8-TK|lwtL}RzMtRkcMn|7(R(sI
z83|v{dVR+OJVNHOBZM%lA7@@p_To-iPo7O3pt$F9=dhkUnJS^Udqt*;_(rR&`wPh!
z7j$UdGTp<{=&)HB<${9NZN@}<f1y7pq!JF4IG;)gDAE5KJzL0YleQIE-z#!KKAqQ8
zK?}B~ziDF*<M#{ACDU+Ia^g|Bq6!stx1#Q|L@ocRs3kUA&-?6FEpJuS9TuwRZ8lcR
zKh63`J#Vu?dXXFDy*k^aajskLDyQ<zq>VI_`SEMaSuPe$w;uW6kYM5?=ZIT*jM(NO
zu_<c^dTu3)*arQ~`IGMq_&P-HkT40cR|aWP-lM8R>^X=`!zh`D-jYF_L{J7X5s1Jv
z1M(YGCA`=JgB%0@FS5JlwlG+&u_<G-JQ9u0Nmrwh>6uw+d@gc(M!F!~i_!&NI05H$
z8dei5gy8VZCj;k5S9uA)r5|}8w&!;EE{q3qEw=lZ#_et_<+AoL#xnio@Ze$E?u=p=
zedr7)OWE2E<^>qy5IVKk@D*^c#bL1DVijyyoCdpS<NIZ>+u}8_S8w#!Idl{CS_VGA
zz>vjX!4np5fjyQD{(=KX7U2i%=6$yKiP_Js3txB~pi6DbxP|&fA2#Te*w=gsZv6m_
bh#mB)C}M@Kiha01KSAfa3!xZ|**pFLlQaBZ

delta 820
zcmYk5O=uHA6vt<>+k7l(n@DUFYPvR|C7>u3m1uE^(GXBXC{`N^q1xg)6oV3%h&4fS
z(6CgR&f0^QTJWOaLDQS4NI*P@AReqJ2sw>krL@x4x=DQ7^kWC!+yC#qH;)<K>{z?j
zJ|^P+!cPB|2#=6qHiQrc`z}81?Z7RPmJQ_oqLH@4EnzLYJ-32JJW~=K$9+yo3(aIx
zT-2`mB)WvfSl9@}xTv7|44H8UXM#~7m$9QvS1u!<%&zC?!QGPDYn_s`r7{=g^KUvv
zTUA9+qt5&{^^{#-c&s)_wBM3FbGuqogqpHgQ<m9{y8csBR#<XFFS84EJzG=e+1U*}
z$4=DsFC#8(=sC8J?&Xg20gWxt>zuFKQ_YncNHb|5>7LWfS}m6icCPVag<#?*yNO4h
zK#Wz0Rh~wW^T-9nKGTm}DEmr>-Ene>BuJb+(}_iXi&i<#9s-d;C?#pgP3Xiy1o;3a
z0uk699rR1Iir`pUCyl`CK_(k*p>Q?E;`-0((PT0uo=gr54qX*{QUe!<#4d3-NmX9h
z+6uF>fFT6KGu9Z)kv`!?T%zxJKeiX=c`vr?IZ_m?modF&^J0H-)Rw?lqQC8JI7}NI
zN$jRK9f@qEP;X(pfP)-DJH|IT1{^eT0=V163UJNDd0;o)+&>BIHSsiXK-<i}=FoW*
zG!?vqf<q?$0({QIv%u}92LFH~YwUsx*o+5l;`@+4R(v6R;&FuDYo5eTy5Hr;724<O
f#36bM{4jk4{ww|9>fH9D385?N$Aho&PZ;Yz2`&2@

diff --git a/stage4/xv6.img b/stage4/xv6.img
index 6ffd19d..1b593b8 100644
--- a/stage4/xv6.img
+++ b/stage4/xv6.img
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:91937ee0ce0a78815628538f19ff3ee6cf003e740e7815fb11539871c39e068e
+oid sha256:465ada267f22651cb6209e385990be1d287f9831c9b4c7c1db2efd0a005e1d6a
 size 5120000
diff --git a/stage5/.vscode/tasks.json b/stage5/.vscode/tasks.json
new file mode 100644
index 0000000..c567be5
--- /dev/null
+++ b/stage5/.vscode/tasks.json
@@ -0,0 +1,19 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Build and QEMU",
+            "type": "shell",
+            "command": "make qemu",
+            "problemMatcher": []
+        },
+        {
+            "label": "Build and QEMU (debug)",
+            "type": "shell",
+            "command": "make qemu-gdb",
+            "problemMatcher": []
+        }
+    ]
+}
\ No newline at end of file
diff --git a/stage5/Makefile b/stage5/Makefile
new file mode 100644
index 0000000..e409242
--- /dev/null
+++ b/stage5/Makefile
@@ -0,0 +1,102 @@
+# Try to infer the correct TOOLPREFIX if not set
+ifndef TOOLPREFIX
+TOOLPREFIX := $(shell if i386-jos-elf-objdump -i 2>&1 | grep '^elf32-i386$$' >/dev/null 2>&1; \
+	then echo 'i386-jos-elf-'; \
+	elif objdump -i 2>&1 | grep 'elf32-i386' >/dev/null 2>&1; \
+	then echo ''; \
+	else echo "***" 1>&2; \
+	echo "*** Error: Couldn't find an i386-*-elf version of GCC/binutils." 1>&2; \
+	echo "*** Is the directory with i386-jos-elf-gcc in your PATH?" 1>&2; \
+	echo "*** If your i386-*-elf toolchain is installed with a command" 1>&2; \
+	echo "*** prefix other than 'i386-jos-elf-', set your TOOLPREFIX" 1>&2; \
+	echo "*** environment variable to that prefix and run 'make' again." 1>&2; \
+	echo "*** To turn off this error, run 'gmake TOOLPREFIX= ...'." 1>&2; \
+	echo "***" 1>&2; exit 1; fi)
+endif
+
+# If the makefile can't find QEMU, specify its path here
+# QEMU = qemu-system-i386
+
+# Try to infer the correct QEMU
+ifndef QEMU
+QEMU = $(shell if which qemu > /dev/null; \
+	then echo qemu; exit; \
+	elif which qemu-system-i386 > /dev/null; \
+	then echo qemu-system-i386; exit; \
+	elif which qemu-system-x86_64 > /dev/null; \
+	then echo qemu-system-x86_64; exit; \
+	else \
+	qemu=/Applications/Q.app/Contents/MacOS/i386-softmmu.app/Contents/MacOS/i386-softmmu; \
+	if test -x $$qemu; then echo $$qemu; exit; fi; fi; \
+	echo "***" 1>&2; \
+	echo "*** Error: Couldn't find a working QEMU executable." 1>&2; \
+	echo "*** Is the directory containing the qemu binary in your PATH" 1>&2; \
+	echo "*** or have you tried setting the QEMU variable in Makefile?" 1>&2; \
+	echo "***" 1>&2; exit 1)
+endif
+
+CC = $(TOOLPREFIX)gcc
+AS = $(TOOLPREFIX)gas
+LD = $(TOOLPREFIX)ld
+OBJCOPY = $(TOOLPREFIX)objcopy
+OBJDUMP = $(TOOLPREFIX)objdump
+CFLAGS = -fno-pic -static -fno-builtin -fno-strict-aliasing -O2 -Wall -MD -ggdb -m32 -Werror -fno-omit-frame-pointer
+CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector)
+ASFLAGS = -m32 -gdwarf-2 -Wa,-divide
+# FreeBSD ld wants ``elf_i386_fbsd''
+LDFLAGS += -m $(shell $(LD) -V | grep elf_i386 2>/dev/null | head -n 1)
+
+# Disable PIE when possible (for Ubuntu 16.10 toolchain)
+ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]no-pie'),)
+CFLAGS += -fno-pie -no-pie
+endif
+ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]nopie'),)
+CFLAGS += -fno-pie -nopie
+endif
+
+xv6.img: bootblock bootblock2
+	dd if=/dev/zero of=xv6.img count=10000
+	dd if=bootblock of=xv6.img conv=notrunc
+	dd if=bootblock2 of=xv6.img seek=1 conv=notrunc
+
+bootblock: bootasm.S 
+	$(CC) $(CFLAGS) -fno-pic -nostdinc -I. -c bootasm.S
+	$(LD) $(LDFLAGS) -N -e start -Ttext 0x7C00 -o bootblock.o bootasm.o 
+	$(OBJCOPY) -S -O binary -j .text bootblock.o bootblock
+	./sign.pl bootblock
+
+bootblock2: bootasm2.S
+	$(CC) $(CFLAGS) -fno-pic -nostdinc -I. -c bootasm2.S
+	$(LD) $(LDFLAGS) -N -e start -Ttext 0x9000 -o bootblock2.o bootasm2.o 
+	$(OBJCOPY) -S -O binary -j .text bootblock2.o bootblock2
+
+
+.PRECIOUS: %.o
+
+clean: 
+	rm -f *.tex *.dvi *.idx *.aux *.log *.ind *.ilg \
+	*.o *.d *.asm *.sym vectors.S bootblock bootblock2 entryother \
+	initcode initcode.out kernel xv6.img fs.img kernelmemfs \
+	xv6memfs.img mkfs \
+	syscall.h syscalltable.h usys.S 
+
+# run in emulators
+
+# try to generate a unique GDB port
+GDBPORT = $(shell expr `id -u` % 5000 + 25000)
+# QEMU's gdb stub command line changed in 0.11
+QEMUGDB = $(shell if $(QEMU) -help | grep -q '^-gdb'; \
+	then echo "-gdb tcp::$(GDBPORT)"; \
+	else echo "-s -p $(GDBPORT)"; fi)
+ifndef CPUS
+CPUS := 1
+endif
+QEMUOPTS = -drive file=xv6.img,index=0,media=disk,format=raw -smp $(CPUS) -m 512 $(QEMUEXTRA)
+
+qemu: xv6.img
+	$(QEMU) -vga std -serial mon:stdio $(QEMUOPTS)
+
+qemu-gdb: xv6.img 
+	@echo "*** Now run 'gdb'." 1>&2
+	$(QEMU) -vga std -serial mon:stdio $(QEMUOPTS) -S -gdb tcp::1234
+
diff --git a/stage5/bootasm.S b/stage5/bootasm.S
new file mode 100644
index 0000000..ebfa7da
--- /dev/null
+++ b/stage5/bootasm.S
@@ -0,0 +1,101 @@
+# When the PC starts, the processor is essentially emulating an 8086 processor, i.e. 
+# a 16-bit processor.  So our initial boot loader code is 16-bit code that will 
+# eventually switch the processor into 32-bit mode.
+
+# This code is linked to assume a starting address of 0x7C00 which is where the BIOS
+# will load a boot segment.
+
+.code16                         # Assemble for 16-bit mode
+.globl start
+start:
+    jmp     real_start
+
+# Write to the console using BIOS.
+# 
+# Input: SI contains the address of the null-terminated string to be displayed
+
+cons_write:
+    movb    $0x0e, %ah           # 0x0e is the INT 10h BIOS call to output the value contained in AL to screen
+
+cons_write_rpt:
+    movb    (%si), %al          # Load the byte at the location contained in the SI register into AL   
+    inc     %si                 # Add 1 to the value in SI
+    cmp     $0, %al             # Compare the value in AL with 0
+    jz      cons_write_done     # If it is zero, then we are done
+    int     $0x10               # Output the character in AL to the screen
+    jmp     cons_write_rpt      # and continue
+
+cons_write_done:                # Something that is called will never return 
+    ret                         # until a 'ret' instruction is encountered.  Labels do 
+                                # not give a program any structure.  They just give a 
+                                # memory location a name that we can use in our code. 
+
+cons_write_crlf:
+    movb    $0x0e, %ah          # Output CR
+    movb    $0x0d, %al
+    int     $0x10
+    movb    $0x0a, %al          # Output LF
+    int     $0x10
+    ret
+
+cons_writeline:
+    call    cons_write
+    call    cons_write_crlf
+    ret    
+
+real_start:
+    cli                         # BIOS enabled interrupts; disable
+
+    # Zero data segment registers DS, ES, and SS.
+    xorw    %ax, %ax            # Set %ax to zero
+    movw    %ax, %ds            # -> Data Segment
+    movw    %ax, %es            # -> Extra Segment
+    movw    %ax, %ss            # -> Stack Segment
+    movw    $0, %sp             # Set the stack to the top of the segment
+
+    movb    %dl, (boot_device) # Boot device number is passed in DL from BIOS. Save it hear since DL might get trashed
+
+    movw    $boot_message, %si  # Display our boot message
+    call    cons_writeline
+
+	movb	$2, %ah				# BIOS function 13h, sub-function 2 is read sectors
+	movb	$7, %al				# Number of sectors to read = 7
+	movw	$0x9000, %bx		# The 7 sectors will be loaded into memory at ES:BX (0000:9000h)
+	movb	$0, %ch				# Use cylinder 0
+	movb 	$0, %dh 			# Use head 0
+	movb	(boot_device), %dl  # Retrieve the ID of our boot device			
+	movb 	$2, %cl				# Start reading at sector 2 (i.e. one after the boot sector)
+	int 	$0x13
+	cmpb	$7, %al				# AL returns the number of sectors read.  If this is not 7, report an error
+	jne		read_failed
+
+    movb    (0x9000), %al     # Check that what we loaded is not empty
+    cmpb    $0, %al
+    je      read_failed
+
+	movb	(boot_device), %dl	# Pass boot device ID to second stage
+    movw    $0x9000, %ax        # Jump to stage 2
+    jmp     *%ax
+
+read_failed:	                # Display error messages
+	movw 	$read_failed_msg, %si
+    call    cons_writeline
+	
+	mov 	$cannot_continue, %si	
+    call    cons_writeline
+	
+endless_loop:                   # Loop forever more
+    jmp     endless_loop    
+
+# Program data
+
+boot_device:
+    .byte   0
+
+boot_message:     
+    .string "Boot Loader V1.0"             
+read_failed_msg:
+    .string "Unable to read stage 2 of the boot process"
+cannot_continue:
+    .string "Cannot continue boot process"
+
diff --git a/stage5/bootasm.d b/stage5/bootasm.d
new file mode 100644
index 0000000..59e6ae8
--- /dev/null
+++ b/stage5/bootasm.d
@@ -0,0 +1 @@
+bootasm.o: bootasm.S
diff --git a/stage5/bootasm.o b/stage5/bootasm.o
new file mode 100644
index 0000000000000000000000000000000000000000..67f80b721f7dc6bee39ecae96a2d7b2bb282780f
GIT binary patch
literal 2032
zcma)6PiP!f82@HBF>N%PZBy)_LZ*g@sLW(rD@wa*{L?5jNFhc%6sEH~Z?}uPGht@Z
z+9E{3g9HgV_vEdmc!&^-U<rjBdRp+<qo9X{96Whxq3iEAJ1_eb!G7@G_xs-Wz3+X0
z-h1m8mKH6`5>1vAWhjY!G&<0{nXy;ph?HgD-YIR2ES{5eq+8zqYj3BtJ<%<1k9W&^
zy+8WBKl^)+D-SjwZ9dri^}firFLq=%l-}?Cox=9mFS7NM+>;F~{#fWvof}&#e=l2b
zb(l*(%U1ul-F4~R>+jx`-gbZgsk|3Osl62Wfr{-<E6$v(gnq59>@>1t<p*|>`b}k@
zvZIEbUR8FD=Bsg3S4kr8`(X&N9))QuT>F=D6)BC%h`a`l5<DqQkTH1-fa$Cb1#7x6
zS(s(|E+-i+a4wEpXDaSV*L5qim|S<JTAi68m|v>SyKdEWFG85Bx^ow+mFj%;eBm;j
zx*Zj?d^c%$%QuosanyAEBtfJd6{Zz8OXZ9(1wZLH%LY2hlf@e0*;!l!4>L3l#L%p-
zEOh7i5$ot=v2>y|TbjyyN7I)uvcQqBriU7U56^t25I_8Q#eR3$KINQ#+i>z9khh6Z
zzI>pw<OSeCEL^nYIObtgmb?OalB$d>c?-OpOSE4EK4Hi!z#T*OfkQ(k_6+$Z@VX&y
z0N*v_Tfm<i@&N=W${|yP%<>PZh%T8_lrd9;{e(Pctdv<D+~c-~=EtevswUp`xRojc
zdhx2M@q#G)hq@lO8-{ti1vMM$1?pO>p5qR#8D0tx3%rKkYOBD+UMFcvJ$o;nelMcJ
zpp9)_JBsjH<`DNWgnK&Y7jpht&adRWk#qJOS5n@{c_ruXki!ovX`#^*<Y+KVvvuAF
z>*%1z<kPv#x>=>cUC7?4licW}eodStjR*XyMzLx;srn)nC-75WoEm-uhl_!#tu?)@
zL<UCnV^iM>8xgi<wtlS^t81p#kNvQz;Ba8Tz0XQnE-==2fd8ub4pEkjc)t&0EMyXD
zhzG*@BmL|>@x8Eq{Fu0>h(UTXU<b4I_c~T+|9^IjNAIB%`b!CN(mKXs#&;P3*;r$I
zd;vPX1z_%>Jt=~~{%fL+<CC20^*dN(ZklLAx`bh#`=wDA=BLlS0<8A{N*BU0f}FID
zozs}A9t4{pC;BAu4>8aE0SA?_#(ba0(C2;)On*AxL-^><Le@l`9>YIS<O2u`Q1IWI
j!k|C;=b5@^fbtE5+XOk$7m07jw7U-n-({M?r0xC&lq?;V

literal 0
HcmV?d00001

diff --git a/stage5/bootasm2.S b/stage5/bootasm2.S
new file mode 100644
index 0000000..d1c216d
--- /dev/null
+++ b/stage5/bootasm2.S
@@ -0,0 +1,1138 @@
+# Second stage of the boot loader
+
+.code16                         # Assemble for 16-bit mode
+.globl start
+start:
+    jmp     real_start
+
+# Write to the console using BIOS.
+# 
+# Input: SI contains the address of the null-terminated string to be displayed
+
+cons_write:
+    movb    $0x0e, %ah           # 0x0e is the INT 10h BIOS call to output the value contained in AL to screen
+
+cons_write_rpt:
+    movb    (%si), %al          # Load the byte at the location contained in the SI register into AL   
+    inc     %si                 # Add 1 to the value in SI
+    cmp     $0, %al             # Compare the value in AL with 0
+    jz      cons_write_done     # If it is zero, then we are done
+    int     $0x10               # Output the character in AL to the screen
+    jmp     cons_write_rpt      # and continue
+
+cons_write_done:                # Something that is called will never return 
+    ret                         # until a 'ret' instruction is encountered.  Labels do 
+                                # not give a program any structure.  They just give a 
+                                # memory location a name that we can use in our code. 
+
+cons_write_crlf:
+    movb    $0x0e, %ah          # Output CR
+    movb    $0x0d, %al
+    int     $0x10
+    movb    $0x0a, %al          # Output LF
+    int     $0x10
+    ret
+
+cons_writeline:
+    call    cons_write
+    call    cons_write_crlf
+    ret    
+
+# Added Write Hex and Int functions to help with debugging
+HexChars:	.ascii "0123456789ABCDEF"
+
+cons_write_hex:    
+    pushw   %bp
+    movw    %sp, %bp
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+	movw	$4, %cx
+    movb    $0x0E, %ah
+	
+hexloop:
+    rol     $4, %bx
+    movw    %bx, %si
+    and     $0x000F, %si
+    movb    HexChars(%si), %al
+	int		$0x10
+	loop	hexloop
+
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+	ret
+
+cons_write_int:
+    pushw   %bp
+    movw    %sp, %bp
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+    movw    $IntBuffer + 4, %si
+    movw    %bx, %ax
+
+    cmpw    $0, %ax
+    jge     getdigit
+
+    xor     %ax, %ax    # Added to handle signed numbers, it adds the minus and then neg's the number
+    movb    $0x0E, %ah
+    movb    $0x2D, %al
+	int		$0x10
+
+    movw    %bx, %ax
+    negw    %ax
+	
+getdigit:
+	xor		%dx, %dx
+	movw	$10, %cx
+	idiv	%cx
+	addb	$48, %dl
+	movb	%dl, (%si)
+	dec		%si
+	cmp		$0, %ax
+	jne		getdigit
+	inc		%si
+	call	cons_write
+
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+	ret
+	
+IntBuffer:   .string "     "
+
+# Draw Line function DrawLine(x0 (4), y0 (6), x1 (8), y1 (10), color (12))
+# Define parameter address positions in stack
+#define color   12
+#define y1      10
+#define x1      8
+#define y0      6
+#define x0      4
+
+# Define local variable positions in stack
+#define deltax  -2
+#define deltay  -4
+#define sx      -6
+#define sy      -8
+#define err     -10
+#define e2      -12
+
+cons_draw_line:        
+    pushw   %bp
+    movw    %sp, %bp
+    subw    $12, %sp    # Make room for our local variables in the stack
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+    movw    $0, err(%bp)      # Make sure that err starts at 0    
+    movw    x1(%bp), %cx      # Load x1 and y1 into the registers
+    movw    y1(%bp), %dx     
+    sub     x0(%bp), %cx      # Remove x/y0 from x/y1 to get the delta values
+    sub     y0(%bp), %dx
+    movw    %cx, deltax(%bp)  # Store the delta values
+    movw    %dx, deltay(%bp)    
+    
+cons_line_check_x:
+    movw    x0(%bp), %cx     # Load x0 into register cx so we can manipulate this value to plot each pixel
+    movw    $1, sx(%bp)      # Preload the x slope with 1
+    cmp     x1(%bp), %cx     # Check if x0 is less than x1 and we can move to y
+    jl      cons_line_check_y
+    negw    sx(%bp)          # If x1 is greater than we need to flip the slope and the x delta values
+    negw    deltax(%bp)      # Flipping the deltax here saves us from having to have an abs function because if 
+                             # x0 was greater than x1 we know we have a negative delta value and we flip it to pos
+
+cons_line_check_y:
+    movw    y0(%bp), %dx     # Load y0 into register dx so we can manipulate this value to plot each pixel
+    movw    $1, sy(%bp)      # Preload the y slope with 1
+    cmpw    y1(%bp), %dx     # Check if y0 is less than y1 and we can start our plotting
+    jl      cons_line_prep_loop
+    negw    sy(%bp)          # if y1 is greater than we need to flip the slope y and delta y values
+    negw    deltay(%bp)
+
+cons_line_prep_loop:
+    movw    deltax(%bp), %ax   # Calculate the err variable by subtracting delta y from delta x
+    sub     deltay(%bp), %ax
+    movw    %ax, err(%bp) 
+
+cons_line_loop_start:
+    pushw   color(%bp)
+    pushw   %dx
+    pushw   %cx
+    call    cons_plot_pixel
+
+    cmpw    x1(%bp), %cx        # Check if x0 and x1 are equal, if not then we are still plotting
+    jne     cons_line_loop_next_point
+    cmpw    y1(%bp), %dx        # Check if y0 and y1 are equal, if not then we are still plotting
+    jne     cons_line_loop_next_point
+    jmp     cons_line_loop_end  # if both x's and y's are equal then we can end the function
+
+cons_line_loop_next_point:
+    movw    err(%bp), %ax    # Load err into ax so that we can change it
+    sal     %ax              # e2 is 2 * err, so we can arithmatic shift left
+
+cons_line_loop_move_y_point:
+    movw    deltay(%bp), %bx
+    negw    %bx                     # We need negative deltay to compare
+    cmpw    %bx, %ax                # Check if we need to apply the slope value to y
+    jle     cons_line_loop_move_x_point
+    negw    %bx                     # Change deltay back to normal
+    subw    %bx, err(%bp)           # Remove the deltay from the err check
+    addw    sx(%bp), %cx            # Add the slope value to the current y value
+    
+cons_line_loop_move_x_point:
+    movw    deltax(%bp), %bx    
+    cmpw    %bx, %ax                # Check if we need to apply the x slope value
+    jge     cons_line_loop_start
+    addw    %bx, err(%bp)           # Add the deltax to the err value
+    addw    sy(%bp), %dx            # Add the slope value to the current x value
+    jmp     cons_line_loop_start    # Go back to the start of the loop
+
+cons_line_loop_end:
+    # Return all the original values to each register before we return back
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+    ret     $10  # Finish the loop and return to the call address
+                 # we also tell it to free the 10 bytes in the stack for the paramters
+                 # 5 x Word (2 bytes)
+
+# Function PlotPixel(pixelx (4), pixely (6), pixelColor (8))
+#define pixelcolor      8
+#define pixely          6
+#define pixelx          4
+
+# I split the pixel plotting off into its own function so that we can use it for any other function that plots pixels
+# and any boundary checks will be applied with the same rules
+cons_plot_pixel:
+    # Setup the stack
+    pushw   %bp
+    movw    %sp, %bp    
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+    xor     %ax, %ax            # Clear ax and bx for use with the draw function
+    xor     %bx, %bx        
+    movw    pixelx(%bp), %cx    # Move x and y into their registers
+    movw    pixely(%bp), %dx
+    
+    cmpw    (screen_width), %cx         # Check if the x value has gone past the width of the screen
+    jg      cons_plot_pixel_end         # If so we ignore the pixel so that we dont draw into unrelated memory
+    cmpw    $0, %cx                     # also check if x has gotten less than 0
+    jl      cons_plot_pixel_end
+
+    cmpw    (screen_height), %dx        # Do the same checks for the y position, i chose to ignore the pixel rather than
+    jg      cons_plot_pixel_end         # end the entire draw because when we come to the circles and polygons we
+    cmpw    $0, %dx                     # can still partially show the output that falls within the boundaries
+    jl      cons_plot_pixel_end
+
+                                    # Pixel point = 0xA0000 + (y * 320) + x    
+    movw    (screen_width), %ax     # Set ax to 320 so that we can multiply this by y   
+    mul     %dx                     # does the (y * 320) part of our math        
+    add     %cx, %ax                # Add the value of x to register ax      
+    movw    %ax, %si                # Move the value of ax into the si counter
+    
+    movw    pixelcolor(%bp), %bx     # Load the color into a register
+    movb    %bl, %es:(%si)           # Load the lower half of the color (since they should only be from 0 to 255)
+                                     # and place it at the given byte in the segment
+
+cons_plot_pixel_end:
+    # Return all the original values to each register before we return back
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+    ret     $6  # Finish the loop and return to the call address
+
+# Draw Line function DrawFilledRect(rectx (4), recty (6), rectWidth (8), rectHeight (10), rectColor (12))
+# Define parameter address positions in stack
+#define rectcolor      12
+#define rectheight     10
+#define rectwidth      8
+#define recty          6
+#define rectx          4
+
+cons_draw_filled_rect:
+    pushw   %bp
+    movw    %sp, %bp    
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+cons_filled_rect_check_x_dir:
+    movw    rectwidth(%bp), %ax             # Check if the user has entered a negative width value and swap the direction to a positive
+    cmpw    $0, %ax
+    jge     cons_filled_rect_check_y_dir
+    add     %ax, rectx(%bp)
+    negw     rectwidth(%bp)
+
+cons_filled_rect_check_y_dir:
+    movw    rectheight(%bp), %ax            # Check if the user has entered a negative height value and swap the direction to a pos
+    cmpw    $0, %ax
+    jge     cons_filled_rect_check_x_zero
+    add     %ax, recty(%bp)
+    negw     rectheight(%bp)    
+
+cons_filled_rect_check_x_zero:
+    movw    rectx(%bp), %ax                 # Check if the x value is a negative value, set it to 0 and figure out the offset so we
+    movw    $0, %bx                         # dont write to unwanted memory locations
+    cmpw    %bx, %ax
+    jge     cons_filled_rect_check_x_screenwidth        
+    movw    %bx, rectx(%bp)                 # Set to x 0
+    sub     %ax, %bx                        # get the distance from 0 to x
+    sub     %bx, rectwidth(%bp)             # take this away from the width
+    jmp     cons_filled_rect_check_width_screenwidth
+
+cons_filled_rect_check_x_screenwidth:    
+    movw    (screen_width), %bx             # Check if the x is outside of the view port, if so just end the call
+    cmpw    %bx, %ax                        # since it will never draw anything
+    jg      cons_filled_rect_loop_end    
+
+cons_filled_rect_check_width_screenwidth:        
+    add     rectwidth(%bp), %ax
+    movw    (screen_width), %bx             # Check if the width ends up outside of the view port
+    cmpw    %bx, %ax
+    jle     cons_filled_rect_check_y_zero
+    sub     %bx, %ax
+    sub     %ax, rectwidth(%bp)             # Remove the excess from the width value so we dont overflow memory
+    
+cons_filled_rect_check_y_zero:
+    movw    recty(%bp), %ax                 # Check if the y value is a negative value, set it to 0 and figure out the offset so we
+    movw    $0, %bx                         # dont write to unwanted memory locations
+    cmpw    %bx, %ax
+    jge     cons_filled_rect_check_y_screenheight
+    movw    %bx, recty(%bp)                 # Set to y 0
+    sub     %ax, %bx                        # get the distance from 0 to y
+    sub     %bx, rectheight(%bp)            # take this away from the height
+    jmp     cons_filled_rect_check_height_screenheight
+
+cons_filled_rect_check_y_screenheight:    
+    movw    (screen_height), %bx            # Check if the y is outside of the view port, if so just end the call
+    cmpw    %bx, %ax                        # since it will never draw anything
+    jg      cons_filled_rect_loop_end     
+
+cons_filled_rect_check_height_screenheight:        
+    add     rectheight(%bp), %ax
+    movw    (screen_height), %bx            # Check if the width ends up outside of the view port
+    cmpw    %bx, %ax
+    jle     cons_filled_rect_setup
+    sub     %bx, %ax
+    sub     %ax, rectheight(%bp)            # Remove the excess from the width value so we dont overflow memory
+
+cons_filled_rect_check_empty:
+    cmpw    $0, rectwidth(%bp)              # Check if the width or height is now zero, end the function if so
+    jle     cons_filled_rect_loop_end
+    cmpw    $0, rectheight(%bp)
+    jle     cons_filled_rect_loop_end
+
+cons_filled_rect_setup:
+    movw    recty(%bp), %dx
+    movw    (screen_width), %ax          # Set ax to 320 so that we can multiply this by y   
+    mul     %dx                          # does the (y * 320) part of our math            
+    add     rectx(%bp), %ax              # Add the value of x to register ax    
+    movw    %ax, %bx                     # Load the memory offset address into the bx register    
+    
+    movw    rectheight(%bp), %si    # Set the counter to our height which should be the number of lines to draw to
+
+cons_filled_rect_loop_start:    
+    movw    rectcolor(%bp), %ax    # Set the color byte for our rep (it uses the AL register for the byte copy)
+    movw    %bx, %di               # move the memory location to the di counter 
+    movw    rectwidth(%bp), %cx    # Set cx to our width so the rep knows when to end
+    cld                            # Clear the direction flag so our rep counter inc's
+    rep     stosb                  # Run the stosb to copy bytes into the data segment til cx is 0
+
+    movw    (screen_width), %cx
+    add     %cx, %bx               # Add 320 to our current y value for the next line
+
+    dec     %si                    # Dex the height counter til we hit 0
+    jnz     cons_filled_rect_loop_start
+
+
+cons_filled_rect_loop_end:
+    # Return all the original values to each register before we return back
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+    ret     $10   # Finish the loop and return to the call address
+                 # we also tell it to free the 10 bytes in the stack for the paramters
+                 # 5 x Word (2 bytes)
+
+# Draw Line function DrawCircle(circlex (4), circley (6), circleRadius (8), circleColor (10))
+# This follows the bresenham circle drawing algorithm so that we can stick to integer values
+# Define parameter address positions in stack
+#define circlecolor       10
+#define circleradius      8
+#define circley           6
+#define circlex           4
+
+# Define local variable positions in stack
+#define circled     -4  # Decision variable
+#define circlexcax  -6
+#define circlexcsx  -8
+#define circleycay  -10
+#define circleycsy  -12
+#define circlexcay  -14
+#define circlexcsy  -16
+#define circleycax  -18
+#define circleycsx  -20
+
+cons_draw_circle:
+    pushw   %bp
+    movw    %sp, %bp
+    subw    $20, %sp    # Make room for our local variables in the stack
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+cons_draw_circle_setup:
+    movw    $0, %cx                     # x starts at 0
+    movw    circleradius(%bp), %dx      # y starts as the radius
+    movw    circleradius(%bp), %bx      # d = 3 - (2 * r), we load the radius into a register
+    sal     %bx                         # and multiply it by 2
+    movw    $3, %ax                     # load a 3 into a register to subtract the above from
+    sub     %bx, %ax            
+    movw    %ax, circled(%bp)           # Move the d variable into the stack
+
+cons_circle_loop_start:
+    # We need to plot all 8 points for this step    
+    xor     %ax, %ax    # Clear a and b registers for use below
+    xor     %bx, %bx
+
+    movw    circlex(%bp), %ax   # Points xc + x, yc + y
+    add     %cx, %ax
+    movw    circley(%bp), %bx
+    add     %dx, %bx
+    movw    %ax, circlexcax(%bp)
+    movw    %bx, circleycay(%bp)
+
+    movw    circlex(%bp), %ax   # Points xc - x, yc - y
+    sub     %cx, %ax
+    movw    circley(%bp), %bx
+    sub     %dx, %bx
+    movw    %ax, circlexcsx(%bp)
+    movw    %bx, circleycsy(%bp)
+
+    movw    circlex(%bp), %ax   # Points xc + y, yc + x
+    add     %dx, %ax
+    movw    circley(%bp), %bx
+    add     %cx, %bx
+    movw    %ax, circlexcay(%bp)
+    movw    %bx, circleycax(%bp)
+
+    movw    circlex(%bp), %ax   # Points xc - y, yc - x
+    sub     %dx, %ax
+    movw    circley(%bp), %bx
+    sub     %cx, %bx
+    movw    %ax, circlexcsy(%bp)
+    movw    %bx, circleycsx(%bp)
+
+    # Plot the 8 pixels for this turn of the circle
+    pushw   circlecolor(%bp)    
+    pushw   circleycay(%bp)
+    pushw   circlexcax(%bp)
+    call    cons_plot_pixel
+
+    pushw   circlecolor(%bp)    
+    pushw   circleycay(%bp)
+    pushw   circlexcsx(%bp)
+    call    cons_plot_pixel
+
+    pushw   circlecolor(%bp)    
+    pushw   circleycsy(%bp)
+    pushw   circlexcax(%bp)
+    call    cons_plot_pixel
+
+    pushw   circlecolor(%bp)    
+    pushw   circleycsy(%bp)
+    pushw   circlexcsx(%bp)
+    call    cons_plot_pixel
+
+    pushw   circlecolor(%bp)    
+    pushw   circleycax(%bp)
+    pushw   circlexcay(%bp)
+    call    cons_plot_pixel
+
+    pushw   circlecolor(%bp)    
+    pushw   circleycax(%bp)
+    pushw   circlexcsy(%bp)
+    call    cons_plot_pixel
+
+    pushw   circlecolor(%bp)    
+    pushw   circleycsx(%bp)
+    pushw   circlexcay(%bp)
+    call    cons_plot_pixel
+
+    pushw   circlecolor(%bp)    
+    pushw   circleycsx(%bp)
+    pushw   circlexcsy(%bp)
+    call    cons_plot_pixel
+
+    inc     %cx                     # Inc the x value    
+    cmpw    $0, circled(%bp)        # check if the decision variable is less than 0
+    jle     cons_circle_skip_y
+    
+    dec     %dx                     # If not we decrement the Y value and calculate the new decision value
+    movw    %cx, %ax                # Move the x value into ax for mul
+    movw    %dx, %bx                # Move the y value into bx since mul destroys the value in dx
+    movw    $4, %si                 # Move 4 into si because we are out of registers
+    sub     %bx, %ax                # d = d + 4 * (x - y) + 10
+    imul    %si                     
+    add     $10, %ax
+    add     %ax, circled(%bp)       # Add the result to the current D value
+    movw    %bx, %dx                # Move y back into the dx register
+    jmp     cons_circle_check_end   # jump over the next section to the end check
+
+cons_circle_skip_y:    
+    movw    %cx, %ax                # If the decision var was greater than 0 we use another formula for d
+    movw    %dx, %bx                # Store y in bx because we are using mul again
+    movw    $4, %si                 # d = d + 4 * x + 6
+    imul    %si
+    add     $6, %ax
+    add     %ax, circled(%bp)
+    movw    %bx, %dx                # Restore y to the dx register
+
+cons_circle_check_end:
+    cmpw    %cx, %dx                # Check if y is greater than or equal to x
+    jge     cons_circle_loop_start  # If so we carry on the loop until it is no longer
+
+cons_circle_loop_end:
+    # Return all the original values to each register before we return back
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+    ret     $8   # Finish the loop and return to the call address
+                 # we also tell it to free the 10 bytes in the stack for the paramters
+                 # 4 x Word (2 bytes)
+
+# Add Point to Array function AddPoint(int arrx (4), int arry (6))
+# The color comes first because i want the user to push pairs of x/y coordinates
+# Define parameter address positions in stack
+#define arry       8
+#define arrx       6
+#define arrptr     4
+
+arr_add_point:
+    pushw   %bp
+    movw    %sp, %bp
+        
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+arr_add_point_setup:
+    movw    arrx(%bp), %cx          # Load X and Y into cx and dx
+    movw    arry(%bp), %dx
+    movw    arrptr(%bp), %si     # Load the address of the array into si
+
+    cmpw    $0x7fff, (%si)       # Check if the user has pointed to an initialized array
+    jne     arr_add_point_end    # If not end the function
+    addw    $2, %si              # Otherwise move the array to the first data position
+
+arr_add_point_start:
+    cmpw    $0x7f7f, (%si)              # Check if the current 
+    jne     arr_add_point_move_addr    
+    movw    %cx, (%si)
+    movw    %dx, 2(%si)
+    jmp     arr_add_point_end
+
+arr_add_point_move_addr:
+    addw    $4, %si    
+    cmpw    $0x7fff, (%si)
+    jne     arr_add_point_start
+
+arr_add_point_end:
+    # Return all the original values to each register before we return back
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp    
+    ret     $6   # Finish the loop and return to the call address
+                 # we also tell it to free the 10 bytes in the stack for the paramters
+                 # 2 x Word (2 bytes)
+
+# Quick memory dump for debugging purposes
+#define dumplen     8
+#define dumpstart   6
+#define dumpptr     4
+arr_dump:
+    pushw   %bp
+    movw    %sp, %bp    
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+arr_dump_setup:
+    movw    dumpptr(%bp), %si
+    addw    dumpstart(%bp), %si
+    movw    dumplen(%bp), %cx
+
+arr_dump_loop:
+    movw    (%si), %bx
+    call    cons_write_hex
+    call    cons_write_crlf
+    add     $2, %si
+    loop    arr_dump_loop
+
+arr_dump_end:
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+    ret     $6
+
+# Clear/Init the Array function ArrayClear(ptr clearptr (4), short clearsize(6))
+# This function fills the array with FF bytes (FF being a value i can use in a loop to end it and not effect the x/y positions)
+#define clearsize   6
+#define clearptr    4
+arr_clear:
+    pushw   %bp
+    movw    %sp, %bp    
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+arr_clear_setup:
+    movb    $0x7f, %al              # Setup the byte to fill the array with
+    movw    clearptr(%bp), %si
+    movw    clearsize(%bp), %cx     # Setup the cx counter for        
+    sal     $2, %cx                 # Multiply by 2 for x AND y values and again for the number of actual bytes
+
+    movw    $0x7fff, (%si)          # Create a full byte at the start we can use in our array functions 
+    addw    $2, %si                 # to make sure a correct address was given
+
+arr_clear_loop_start:    
+    movb    %al, (%si)    
+    inc     %si
+    loop    arr_clear_loop_start
+
+arr_clear_add_end_bytes:
+    movw    $0x7fff, (%si)    
+
+arr_clear_loop_end:
+    # Return all the original values to each register before we return back
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+    ret     $4
+
+# Draw Polygon function DrawPolygon(ptr polygonarray (2), short polygoncolor(4)...)
+# Accepts the address for the array and a color for the lines
+# Define parameter address positions in stack
+#define polygoncolor       10
+#define polygonoffy        8
+#define polygonoffx        6
+#define polygonarray       4
+
+cons_draw_polygon:
+    pushw   %bp
+    movw    %sp, %bp
+    #subw    $20, %sp    # Make room for our local variables in the stack
+    
+    # Store existing register values to the stack so we can restore later
+    pushw   %ax
+    pushw   %bx
+    pushw   %cx
+    pushw   %dx
+    pushw   %si
+    pushw   %di
+
+cons_draw_polygon_setup:
+    movw    polygonarray(%bp), %si
+    cmpw    $0x7fff, (%si)          # Check if the user has pointed to an initialized array
+    jne     cons_polygon_loop_end   # If not end the function
+    addw    $2, %si                 # Otherwise move the array to the first data position
+
+cons_draw_polygon_loop_next:
+    cmpw    $0x7f7f, (%si)
+    je      cons_polygon_loop_end
+    cmpw    $0x7fff, (%si)
+    je      cons_polygon_loop_end
+
+cons_polygon_loop_map_xy0:
+    movw    (%si), %ax    # Move x0 and y0 into ax and bx
+    movw    2(%si), %bx
+    cmpw    $0x7f7f, 4(%si)
+    je      cons_polygon_loop_map_end
+    cmpw    $0x7fff, 4(%si)
+    je      cons_polygon_loop_map_end
+    movw    4(%si), %cx
+    movw    6(%si), %dx
+    jmp     cons_polygon_loop_draw_line
+
+cons_polygon_loop_map_end:
+    movw    polygonarray(%bp), %di
+    movw    2(%di), %cx
+    movw    4(%di), %dx
+
+cons_polygon_loop_draw_line:
+    addw    polygonoffx(%bp), %ax
+    addw    polygonoffx(%bp), %cx
+    addw    polygonoffy(%bp), %bx
+    addw    polygonoffy(%bp), %dx
+
+    pushw   polygoncolor(%bp)
+    pushw   %dx
+    pushw   %cx
+    pushw   %bx
+    pushw   %ax
+    call    cons_draw_line
+
+    addw    $4, %si
+    jmp     cons_draw_polygon_loop_next
+
+cons_polygon_loop_end:
+    # Return all the original values to each register before we return back
+    popw    %di
+    popw    %si
+    popw    %dx
+    popw    %cx
+    popw    %bx
+    popw    %ax
+    movw    %bp, %sp
+    popw    %bp
+    ret     $8  # Finish the loop and return to the call address
+                 # we also tell it to free the 10 bytes in the stack for the paramters
+                 # 4 x Word (2 bytes)
+
+real_start:
+    movw    $0xA000, %bx             # Set the start of the video memory location
+    movw    %bx, %es                 # Move that address into the "extra segment" es register
+
+    movw    $boot_message, %si  # Display our boot message
+    call    cons_writeline
+
+draw_start:
+    # Set the Video mode to VGA 320 x 200 x 256    
+    movb    $0, %ah
+    movb    $0x13, %al
+    int     $0x10
+    xor     %ax, %ax
+
+setup_polygon_arrays:
+    # Create the star polygon array using the static memory location
+    pushw   $10                 # Number of points
+    pushw   $polygon_array      # Address for array to be created
+    call    arr_clear
+
+    # Map points for the star polygon array
+    pushw   $-6
+    pushw   $0
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $0
+    pushw   $2
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $0
+    pushw   $8
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $4
+    pushw   $3
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $9
+    pushw   $5
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $6
+    pushw   $0
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $9
+    pushw   $-7
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $4
+    pushw   $-3
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $0
+    pushw   $-8
+    pushw   $polygon_array
+    call    arr_add_point
+    pushw   $0
+    pushw   $-2
+    pushw   $polygon_array
+    call    arr_add_point
+
+    # Create the mountains polygon array using a dynamic memory location
+    pushw   $9                  # Number of Coord pairs
+    pushw   $0x1000             # Address for array to be created
+    call    arr_clear
+
+    # Map points for the star polygon array
+    pushw   (screen_height)
+    pushw   $0
+    pushw   $0x1000
+    call    arr_add_point
+    pushw   $140
+    pushw   $40
+    pushw   $0x1000
+    call    arr_add_point
+    pushw   $160
+    pushw   $60
+    pushw   $0x1000
+    call    arr_add_point
+    pushw   $120
+    pushw   $100
+    pushw   $0x1000
+    call    arr_add_point
+    pushw   (screen_height)
+    pushw   $150
+    pushw   $0x1000
+    call    arr_add_point
+    pushw   $180
+    pushw   $180
+    pushw   $0x1000
+    call    arr_add_point
+    pushw   (screen_height)
+    pushw   $210
+    pushw   $0x1000
+    call    arr_add_point
+    pushw   $90
+    pushw   $250
+    pushw   $0x1000
+    call    arr_add_point
+    pushw   (screen_height)
+    pushw   $300
+    pushw   $0x1000
+    call    arr_add_point    
+
+    # Create the mountains polygon array using a dynamic memory location
+    pushw   $10                  # Number of Coord pairs
+    pushw   $0x1050              # Address for array to be created
+    call    arr_clear
+
+    # Array for the moon polygon
+    pushw   $0
+    pushw   $0
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $5
+    pushw   $8
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $14
+    pushw   $11
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $23
+    pushw   $8
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $29
+    pushw   $0
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $29
+    pushw   $9
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $23
+    pushw   $16
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $15
+    pushw   $19
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $6
+    pushw   $17
+    pushw   $0x1050
+    call    arr_add_point
+    pushw   $0
+    pushw   $9
+    pushw   $0x1050
+    call    arr_add_point
+
+    # Draw the mountain polygon
+    pushw   $6                  # Color
+    pushw   $0                  # Y Offset
+    pushw   $0                  # X Offset
+    pushw   $0x1000             # Address of the Array
+    call    cons_draw_polygon
+
+    # Draw the moon polygon
+    pushw   $7                  # Color
+    pushw   $30                  # Y Offset
+    pushw   $280                 # X Offset
+    pushw   $0x1050             # Address of the Array
+    call    cons_draw_polygon
+
+draw_stars:    
+    # Draw the star polygons
+    pushw   $14
+    pushw   $20
+    pushw   $20
+    pushw   $polygon_array
+    call    cons_draw_polygon
+
+    pushw   $14
+    pushw   $20
+    pushw   $80
+    pushw   $polygon_array
+    call    cons_draw_polygon
+
+    pushw   $14
+    pushw   $25
+    pushw   $130
+    pushw   $polygon_array
+    call    cons_draw_polygon
+
+    pushw   $14
+    pushw   $10
+    pushw   $250
+    pushw   $polygon_array
+    call    cons_draw_polygon
+
+    pushw   $14
+    pushw   $100
+    pushw   $200
+    pushw   $polygon_array
+    call    cons_draw_polygon
+
+    pushw   $14
+    pushw   $60
+    pushw   $50
+    pushw   $polygon_array
+    call    cons_draw_polygon
+
+    # Setup the registers to loop through the flag stripes
+    movw    $150, %ax   # x Offset
+    movw    $25, %bx    # y Offset
+    movw    $6, %cx     # Sets of stripes (12 red/white) for the loop to decrement
+    
+draw_flag_loop:
+    # Draw our filled rectangles for the flag stripes
+    add     $5, %bx   # add the height of stripe to the y offset
+
+    pushw   $12       # Color        
+    pushw   $5        # height
+    pushw   $120      # width
+    pushw   %bx       # y
+    pushw   %ax       # x
+    call    cons_draw_filled_rect
+
+    add     $5, %bx   # add the height of stripe to the y offset  
+    pushw   $15       # Color        
+    pushw   $5        # height
+    pushw   $120      # width
+    pushw   %bx       # y
+    pushw   %ax       # x
+    call    cons_draw_filled_rect
+    loop    draw_flag_loop
+
+draw_flag_loop_end:
+    # Draw the 13th stripe
+    add     $5, %bx
+    pushw   $12       # Color        
+    pushw   $5        # height
+    pushw   $120      # width
+    pushw   %bx       # y
+    pushw   %ax       # x
+    call    cons_draw_filled_rect
+
+    # Draw the blue box that would hold the stars
+    pushw   $1        # Color        
+    pushw   $35       # height
+    pushw   $45       # width
+    pushw   $30       # y
+    pushw   $150      # x
+    call    cons_draw_filled_rect
+
+    pushw   $6        # Color        
+    pushw   $180      # height
+    pushw   $5        # width
+    pushw   $30       # y
+    pushw   $145      # x
+    call    cons_draw_filled_rect
+    
+    # Draw some circles to show off that function
+    pushw   $14       # Color    
+    pushw   $3       # radius
+    pushw   $27      # y
+    pushw   $147      # x
+    call    cons_draw_circle
+
+    pushw   $2        # Color        
+    pushw   $25       # radius
+    pushw   $90       # y
+    pushw   $90       # x
+    call    cons_draw_circle    
+
+    pushw   $15       # Color    
+    pushw   $5       # radius
+    pushw   $85      # y
+    pushw   $80      # x
+    call    cons_draw_circle
+
+    pushw   $15       # Color    
+    pushw   $5       # radius
+    pushw   $85      # y
+    pushw   $100      # x
+    call    cons_draw_circle
+    
+    # Plot a line, we add the parameters to the stack in reverse order
+    pushw   $15      # Color
+    pushw   $100      # y1
+    pushw   $75      # x1
+    pushw   $105      # y0
+    pushw   $90      # x0
+    call    cons_draw_line
+
+    pushw   $15      # Color
+    pushw   $100      # y1
+    pushw   $105      # x1
+    pushw   $105      # y0
+    pushw   $90      # x0
+    call    cons_draw_line    
+
+    # Draw the rest of the lines
+    pushw   $2       # Color
+    pushw   $210      # y1
+    pushw   $90       # x1
+    pushw   $115       # y0
+    pushw   $90      # x0
+    call    cons_draw_line
+
+    pushw   $2      # Color
+    pushw   $110      # y1
+    pushw   $145      # x1
+    pushw   $130     # y0
+    pushw   $90      # x0
+    call    cons_draw_line
+
+    # Line borders
+    pushw   $9       # Color
+    pushw   $10      # y1
+    pushw   $310     # x1
+    pushw   $10      # y0
+    pushw   $10      # x0
+    call    cons_draw_line
+    
+    pushw   $10      # Color
+    pushw   $190     # y1
+    pushw   $310     # x1
+    pushw   $10      # y0
+    pushw   $310     # x0
+    call    cons_draw_line
+
+    pushw   $13      # Color
+    pushw   $190     # y1
+    pushw   $10      # x1
+    pushw   $190     # y0
+    pushw   $310     # x0
+    call    cons_draw_line
+
+    pushw   $15      # Color
+    pushw   $10      # y1
+    pushw   $10      # x1
+    pushw   $190     # y0
+    pushw   $10      # x0
+    call    cons_draw_line
+
+endless_loop:                   # Loop forever more
+    jmp     endless_loop    
+
+# Program data
+boot_message:     
+    .string "Boot Loader Stage 2 loaded"             
+
+screen_width:
+    .word   320
+screen_height:
+    .word   200
+
+polygon_array:         # Create some memory space for our polygon points array
+    .fill   40         # Fill array with data to the size of the array
\ No newline at end of file
diff --git a/stage5/bootasm2.d b/stage5/bootasm2.d
new file mode 100644
index 0000000..74df401
--- /dev/null
+++ b/stage5/bootasm2.d
@@ -0,0 +1 @@
+bootasm2.o: bootasm2.S
diff --git a/stage5/bootasm2.o b/stage5/bootasm2.o
new file mode 100644
index 0000000000000000000000000000000000000000..674eaa46ab11b32d2a799ce80c8f8f7b870e4207
GIT binary patch
literal 6912
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
bh4K}eVBRPeHTqpE`n`$zo>VQ`P51jh=9ITt

literal 0
HcmV?d00001

diff --git a/stage5/bootblock b/stage5/bootblock
new file mode 100644
index 0000000000000000000000000000000000000000..95937cb7cd534fc98e8774a40d52622b32d8a199
GIT binary patch
literal 512
zcmaE@u!XOS#m$DHgypQj>#v8m@NM8dE3kp<tia(HPyWAn|NrnW!vlRc`VRD6*u%ik
zA(mUSFR$js<NsTjHn8tzn6Q;$8$%aRa3j-MVH@^Rfdvc`fJSkGgmy4Y`2S#Eea(w)
z|M#t`d9mUD>wgSR`S~RZKKY3$sYME5hI$4Jp?Qf(IjIUI`3gm;i75)jC5h>&3PuX~
sX$mD7sR~IT<po9g$*IM~49<ypc|dM*eqKptUMZR+!zdsp1VUE<0KGF;%K!iX

literal 0
HcmV?d00001

diff --git a/stage5/bootblock.o b/stage5/bootblock.o
new file mode 100644
index 0000000000000000000000000000000000000000..9fb59f8d94f2dda8f35f8f416ace11d50575deab
GIT binary patch
literal 1644
zcma)+ziSjh6vy9gE<__<E-G3?aAOFF#cj?XAef84P(gzTQLzw)z1z9-@NPHmZZv^|
zSXhWfNZ}t~VPzE|il7D|f?5PDEd?zOf{2BUg6H?m?%<fp2XEf{y!U2iXLe@hPfwn)
zEQ_?*)I*BeM28Su&ZU_{<RHF}wot#yU*a%oSl`01_CdMty0e_WpF1;7Np7vM{$q7H
zzqEC&u++a+SnYi2cD{92f0kY^d|Y_F@ZlxVy`8Q0O3?0n?k?L)eJ^P7DLte62tKjb
zwvYGC6duwdhT6=b=d{@Uv@+lBJnODJZg-Zt>%Zw_7$(kS==m~ou9S*nbUE-UP3a_|
z6G_i^;>4><=YSK|oaDN6DqKDtg;g2Hbjk|?U^NVqMliD>iIouThT6)@HX>WE3ZWT>
z_L8NNYTwj`D6bzW7i!(H2C1-X(AqZ8lOM{D=C}7EI;}e9Xg^n2*020lHrx>kXO9}g
zw)WTq_9&vH8tS!qf}VcsaLFBZUAHuf#&t)^<&hC~CML@hu3L89^MJ9kJ9fTYDo>P;
z+1D^AuicAV#VK-I(r<WfToY4s@x>^tyIve)M_MvSO0L?n!*uq-W#`0{bD((e$p3Zt
zJ3fE#KcZHXMRN4Ly9NGUtRxkScEYg@9tP(O9s>^;d>mXb_#$}7U;%C!d;=U9JPQ^E
z-v!Sb`~dve;78ya20sD6&A5PH_G$ya0lzcy1+cm=FkDZ1uR_8pZ3=98ln@SLEN(}Q
zL>jJ$rp=7-!{DEEHEPz3@@4~R9$onIR->BvE&N>E1D?zmHLuZ>zUhlrT&JqK4MN`r
zl7ZhuH_;5kX%eCWH~mZ@eJ}Aypn#|t&$SY-0-Hpsy{^4P&L&j!Wo4!=yvPgcGS=7#
zYN7VMN+puFG^y{;I$<C)jOioZ$N!We)bY9FcZv6&-z<KowCFR*XHEN@a{vxInQY1|
zpFy+kI3T^1X@Sm-Z>W<<?8wGoqwCHYKF8;fNZ83l*Ifa#&-1f<1sqLX)pCy2%dD>3
zhlh(FAT7F%ZThCAnX3Q?!Og%tGzaDL%G?9hG7EUG0hY&M8HAd3CosTGl}Q_2_XmTa
BCcXdw

literal 0
HcmV?d00001

diff --git a/stage5/bootblock2 b/stage5/bootblock2
new file mode 100644
index 0000000000000000000000000000000000000000..88f99f45e647f42f581c5c2d1738f979a1d0453c
GIT binary patch
literal 1850
zcma))Uu+ar6vprD-VW2DY!|3P6>F1<aj7H}6>VA-P{yFRDJ?8mbqvW8hbs{y?S_Z4
z3yz5$Mh!&MK9DHJ@Sra=u^Jje)3OO|#En89*w`Ri#a!K{G=SazGoCZEbo=0go6YX;
zJLkLSo^$X0tA!5wj!~tRbkT%A^-p}zH?Sn(ACMFNIRC@uH|_YkruC0K{=|kSpK9K;
z`MKw}C_9ZCZ5`X&L%W738T5_Dsqu^cXZ5l78;&RZQ?qZVov*yQ+n9bmKJOd;?6{HC
zGvshp(+HGboA4XSbh7EnkWA9qBNx{7)&wEjJ)`i0c6oU{eh3uNr>ork#*{fi%%Eh3
z<i;Rv42ee2GC~D2NXL|%Kw5%QkC;|-Y1J}A;+T?wP)Np5Cao4s#cEUvhB9YIs@k{n
zr_tWM2n^kx)M`_iyZo!E7SfZ=$*7c`45)M7V9r#n=H%fY1rVW3YHYr>3o^Fl_S7`e
zGzksBhAlo{f9yd$OM32Wx!2zxtI>0$r}_(De|kz7H!hm0^l<O0at*Ou!&D?Z9Z^td
zT9r&iE-C0-HWhk~5NJa-R2ql}R4FByb-w=QWNg1zDPgoCkPLuO#CflXUKzc9^ltPj
zvWwBB=#}-TM51f-s7#^{LGw<VUWFQQGXi^78Q0;Q3%9>EVJP8JuzR}PxHG&yT~m4k
za3diJhP(XxSuY7Bzbx3!ktkFcH&s!XFqE93&cPS~)B(^LL%jo9_zClu4CR)g&R`yO
z0Q9V(PTLXLj=)vr_@~xg&hTEB?_j)Vo-_O%muKwAEgqidS-#t4sCJ8Qo99`+(b}Xx
zQ?N;N#f!$cF)>V`@$`&7A`4={HhxYmD@8FTy0PZ(t3O&@ew`Pj1=kl8@dzUHXsaFT
zuGKGkj<&{P-HVJWV}~bIsb6#xf0vJN;oV25HzMMrUd2xr_>lrEpSt~@)`1x8VFty~
z-#lZ~j)Ae4DpPsnvY#&KtJG1j)KS+KY_RKDlbWx2j`q-4tg9OSAS9XFsJTN-Rhm(1
zzU(n~Qm-O<gQ8cJydeqBzkPd08$SrW(bTu)y(DsuoccIEe7lcN<Oj*X@`S%>gvr{n
ze!kUaIYyAKT8uCcQUXarid&2_FVc|3Dp>{68H<VTiqja&V(cXPibyALZ3gKBBn#;<
z_%!0@*DQO3zaQ2D@3XWI33~)lwX{=&wIX&{><|khZFRg_pJQ&dv_XPjNUU=cR~*q`
zu}&@L;7T|CsDP%$7EIUX=Wk&T1Swl&6)+Rf%_8%$#Yi`bY=s+}EV2h&-({pq%#LB!
zk95Ass@Za+Z;CMcQlzhnP}%W)jxpQ?_HDG-B37rZ6wp#<!A3Q#29IEw%WcRaa;^5B
zbL!BS4|;_eATy03tc^S3I*L}d9upJAvwh@TEg2Gt9<N|kFv}sh=)HMV)g`qnKQ*;5
z`$C=xtbwhChWZF^&NC5?5WIET3BuRpp}LpduYE%J)jadCTGq)r`44%g+)mcUNAF^o
ze}@=mFR^`KxhLm{eU6ZF@MNwKSbGpsxhxcV8_L6QAX8a*AF{SVU^0{WwJh*3aU}fk
zM3yZ9eK*L@XQ3__oftopO<9`{9O$awc3@9<@4NLKU3=c#Tfe@3KguxKD2$W;`}r3L
Cg(0N?

literal 0
HcmV?d00001

diff --git a/stage5/bootblock2.o b/stage5/bootblock2.o
new file mode 100644
index 0000000000000000000000000000000000000000..f2337986771528a1d4880dccece1c1b14a98f258
GIT binary patch
literal 6304
zcma)=e{fXQ702)X$g(V9vtZ;$LCl)s5K(qF;13|1A5vE_m;nP(u-(^9_L1F3l1+Cv
zA+eBP<4jq%wfLhjwKEmz_($76q+{$zRR+lnFx9jb2F;YQDy{X=Fo<Bu?@hnwzV~)-
zK+!vS@14&%-+S)4_ucp2PP*?~7ciMj%xGq2VVw3bwgOIdjuu(Lir`<uW-tejZzMM~
zbgY`D9k}q=xz*NQ=Tp`|8B1FGU4#GY>vbNS+3z~&=y&z0|DIGopX~GcN|&#=^RBz^
zSy^@On(y5g*p&KoeeH&a>mE5|WxdX~`>d&d_WY;dsV9r~^t;Ypl!99}KlW(q{15uF
zy2HQOlN#t5W;^qJN09!GephN>Xux;!kb@14>^kb*U08!?+l7Fdn9OxAqQ;P<=X}04
z-toW{#?m$Rbe&^qjdf|AEmf0A)s3fXtj7bRCbqi9zQZ;Y932W~(sj1ufnm7n9ON1v
z3XZ1(nWcg8RN%^Fd;Y^4R6ohvra{nV9$cIbTzT)~bZ~s=%*uf-`_P$^;1x^FXgZi#
zIk59@CP3Zr;PGr}M;%m_R+I0D?+gmSfUBL(ecd<rjIbTwSv|+Kue-2kl<g>Z$+>Un
ztm#DRSUPCGb@#$t4qGlqI$)>Ov6%wap`bk-aOi}}9qEAe4aQK0BNeok^pyndgZA_y
z=f0H#-A$H&Zg%CB43q!@wyf4hS_f%eq^-0B9GclRi?oiOE<5YGt*6Vuy1t9zd6|}g
zHPx4H$C&x4kFd_;mw%teq)hMBw4Kit&L`h<zEIx-xFdCTOzypZy>4M81HT=g<VzB;
znogvHHq)t8U^ErHf@zcxmw<;;!7st4zf=63RNzu7c!A=?CE$yx;Q7gR$7DNh)u{S>
z#;}Lg-J1O+`FCXPVYOAWFHE*yQo~vMqWY+2Biki)UDm#+R%WVt%Eu>J*W3qFCsL;l
zTT%GXg`Oi0lWlx5^^d{Xx|e)5&A0L|1wUV$+nq=4!tJZE(Gs*<pD3H`Zkyk8%=|=I
zcX!*gRDNosd2o8qF)i@l+!BiSzTIkRx6!6vsJ=X|?ixq;vzNb8daxT~q-$(%e_}pv
zo$Q8iw>5BfjO?7=D%7P{RHIjvypIY@R-~=z@0*|4VeRft7T^MxJ-yDF-e?<~p6;@y
zA2O#mSuFvZrN(9n+AVc<tpCFsYS*g?)Mg!gEjN~(y}|ZB-FNu%UiH*iFFSZczsq+-
zaYSbCQ`b%^qY5MIgN(uyGg<v)*~#k5C|1Qn)}f3tUCATsm5gH3db~`&5%T?-bQ5Gf
zLw$$I`YBl%vUWljVJ`K<%;a6Jedr52nu+|3DND!<W+MBUQbuNNM(I$(WUb}e$X+fk
z%S3t^{UPAh0w*~XXOu0GQEtxD{I{D(G$VuAt#_&0s0K#X$b^!IIl=mTLUAfH$oh0b
znXCEEOei;Ly7$PMPSN8Ob&>Vfgi@f~K-Q}hnENcUem8;4T=ydRXcUaQG^0#Y7DeWn
zNU|t{feMvET7ub{y`F3v+4Cbm;j50ioTwFZK;%3@IC6r+M+9X`DFseVyuO#cF`pf>
zv7Wv>B_DI?z>Sv2hzfLiWbEu&F?#=)Vp58gJ5bPGrmh@QY*<2Q7e$_7>TP4lZc!FQ
zo@43<V~SasuWV7asPB&Pbeoj*>f44HR{un1SgBT`klZ-RA<Dr%iY;@Jp>G1A(GetS
zL3&IMI5>j+;fUO2QXGmy{cr^KVa5?BwSPpJ2{xSSTO-H|A@`}Tj0|S(jm45h>tdm>
z951R(h8pFf(xN89Fsn43pl{{3Yzv_?bFEeDp?_bE?rs=)%*2EIJ53+pKRYQr1BVxf
zX_sjhbIqM)nq6RVE^sb(-jE0HMhkVcvfD^uGL1QB(uGpsfN?X=W;WeyE-){Km+=$J
zGt&Tb*Z4eckH_O%jFZPx?DyN}xqWVGxA=X2kH6aE<>dCbi?ac*-wUzV<MTk_apSMt
z5Ls?ax;+(~ZrSXoR^i_aRV6=H5W3yv)Xhiv(cr<!Uz*J@v&<L>{_<*%-;0B^UVl|q
zG{X>~WJ;l*s32c8a#tfWd8az6J=H#vdNHQo?XC8@muEB1D>Dj5N`yU?7?8U2YNwo$
z7<`?>z1fRZrO{Cfuc6xKsmTtNFBFdnR-jl+usXK{(*;2V7RRsM65NC}`q~u3TV7q^
zar<&<u_juIVhoF<7}LMmvl&WETC15#D9^2RmEY^H#7dQ72~h*T5#Mk{IY`Y{h*pVr
zsRmM`D}`_+**9b|MuSclQz`y({e<~Z0^<aU-(N{VzJKWAFGUJmDFOAPgghCkJh>B(
zYwST?S`3xK4?sV<$uRj~xK^0g;=!rMlOIYnmoBSio@O~54S5n<rP|KK`gp9-6G|lH
zM50-4N%}kqdM(_^?yuQYR8?D4x@`G9->!o&06mshHSHasIj!uA$$XgQ&l@5Wn+wx|
zCs=DHb_<L=fqh_?z*XQ`0&f5>6!?eWVu7RJ<pOtrs|4N!eoWwBfL{>!SK!A5J^<b?
z@E^f_0{4O67x*;zoWSS6mjup$?|ud+-b~Di1+xjf1iVz>)!-QdKLTDTa02Yym&>;c
z924TtgIz-W0Qkp3{B`h?0-pvyEAS=oet}*181xE!C-_Z)gWx64=IZGHzbnM|f<G4c
zO|UBPXJD()KLZ{X;tTNEC=}v%gI5Ur0Ju_M30y01J9y4>x%yJzB?7+)UM6rac$L6M
z!D|G5AG}Rq6}(B{ad5rBh4@l#7x*UdE`e_crvzRF-Yf9^-~$400RKVY5cn;D+rdW#
zej0pC;FrKB1%4HLM&NhArNZ<33HUQ1J^{Wg@LYV`or2y6o-6P};LCe+>%RrOR*1{s
z4FW$7o-OR(-QeC|=K4PewhQ?VfNvG}HSiY#9|f<{^SSU-<F8lo3%FlpLVOktr9Z!<
zXW7?ZjK$?plZ4l3JjohjEeUCRJergRQ;N5W5h)yNnG$Y@H*FQ<O;Lm&kUQ2yLh*#)
zmm+cp!_gFrwTkX&OOmZ^N#5JGb*mg_jdC&^ZH(#zhU1~_5>Lo0BTH(C$PL@14lRY?
z=@dMzak*8>4a8N1;xt>EVo9kr+95Xy9l5AQ?m#3)h2@6j5xFINwW~SSE=!$XE$6Wg
zJ(g&Q%W{jfJsM6%v?RF-BucCcB674bBF=wnw5drBOL4hD_X-YUHKcGft|h%T*m=ER
zhxE7{k9}R&4oNFYDEiv`Ja~QK)Wy3tMdx*^=+u*oD|2lQE&2`8gq&>Cci*)c<mT3-
zzKg`*)f<Oz%7$pXp-F!X1cxLHph@^P6!)F(PHc;|O8RKJOWWDmJtp=iXDA+*LgBE!
zou-gJ>{Q=1ee^1(s`ws7+BnZ2ZfkDM8bVg`YY!Cl=47PDGK93w+!8uzEG!@O)todB
zB#`PmlX8L&D2ORDfAILiw#J$|8)Gfkdc?KXMcQJ2Wq&P1kG7U+N{{AHtJKly{hCNN
z-;_SNcN4u!rDpsh#V=9D-P+rf?*-g0UcZFNhdL8%3g*-a&D`1)YSh-5=gA^}L7<K%
zjH1OQsUD^_kR*pg$q>HyiO%L^s2<m3T)RdLD@hYy7MAPV8c|88r4h@nW3**!%&<fC
z^>Mk~ApYjnRY)YdF>>7ae0_`S0%-8nVf4Rj`VMWxh5o;7G>TDk<1lREJ<t@9p*OpJ
z_2Me(4nnus5DBp|!KUzO=nBcun~~!|uwhf^9CVN38)`HoRtE>!G(NQ|{C9xHFdD_^
z2<cZtw-Y+UCas~PD}EYg+d=3q;<w0jc&c&0WG)=ULOE<doTu^4HyY)kM&Ef+*EWZ-
LAMuEGGIak3WBuZQ

literal 0
HcmV?d00001

diff --git a/stage5/sign.pl b/stage5/sign.pl
new file mode 100644
index 0000000..d793035
--- /dev/null
+++ b/stage5/sign.pl
@@ -0,0 +1,19 @@
+#!/usr/bin/perl
+
+open(SIG, $ARGV[0]) || die "open $ARGV[0]: $!";
+
+$n = sysread(SIG, $buf, 1000);
+
+if($n > 510){
+  print STDERR "boot block too large: $n bytes (max 510)\n";
+  exit 1;
+}
+
+print STDERR "boot block is $n bytes (max 510)\n";
+
+$buf .= "\0" x (510-$n);
+$buf .= "\x55\xAA";
+
+open(SIG, ">$ARGV[0]") || die "open >$ARGV[0]: $!";
+print SIG $buf;
+close SIG;
diff --git a/stage5/xv6.img b/stage5/xv6.img
new file mode 100644
index 0000000..621fd09
--- /dev/null
+++ b/stage5/xv6.img
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:288eb982d8be8d0bae83fd38df2c56107fba15cf66fd1beb675960fa8ab77132
+size 5120000