The basics

Asks user for start and end address range. Stores input as strings.
Strings will need to be converted to hex.
Included .gitignore to ignore the s-record and list files as they are
products of our build and only needed locally for debugging.
Rough Cut at I/O

Takes a command, starting addr and ending addr.
Tests

Placed at 0x7000. From the project documentation, I copied over all
op-codes we are required to be able to disassemble. Then, starting from
MOVE and working my way down, I wrote test data with various input for
<source> and <destination> to cover the effective addressing modes we
are required to disassemble. I also applied this to the size ranges each
instruction can address. I'm not finished and the last of the op-code
instructions are commented out. In this way I hope to address most
possible combinations. After we get the basics, it would be good to
throw in a wrench or two.
Updated I/O  - Clarified comments and Optimized Shift functions

Still need to refactor the Subroutines
More tests, and formatting
Finished test op-codes

Coded all possible op-code and effective address combinations that will
be tested, including varying sizes, with the exception of varying the
register numbers, direct data input, or direct addresses. The end
product is a large section of code which aims to break the disassembler
and exploit any possible errors in logic.
Outlined Op-code and EA routines
Added to the outline of Op-code and EA routines

Also, barely started coding the op-code routine
Start of an Op-code routine

Isolates first four bits and branches. Still trying to figure out the
best way to approach this. Lots of time spent just reading material to
grasp best practices.
Successful decode of NOP

Established bit shift and isolation methods, still needs to be
modularized, but is currently effective. May need some tweaking due to
unforeseeable requirements with other op-codes. Current setup isolates
bits to be tested, then branches and tests more bits until paired down
to a single op-code that can be pushed to buffer. Each branching scheme
ends with a BNE (not equal) where it will eventually push the generic
'DATA' term to the buffer.
First cut at AE Subroutine.

Need to add test cases, and individual subroutines for each different
input type (byte, word, long).
Completed EA Routine

I've added pretty much all of the EA Routine (and corresponding
Subroutines). I've also renamed some subroutines I used to be more
friendly, and added a Library for the EA Section. We now need to write
test cases for this section, and then link all components together.
Modularized bit isolation and expanded op-code decode tree
Finished more of the op-code routine
Done with most of the op-codes

Still need to do MOVE, MOVEA, Bcc, ASd, ROd
Complete decode of all project op-codes complete

Generic DATA is in use for any unrecognized op-code, but it's not
thoroughly tested. Still need to implement receiving op-code from I/O
and send/receiving to and from EA
Tied together IO and Op-code

Next steps: writing op-code to buffer
Op-code routine pushes to good buffer
The beginning of a subroutine to send bits to EA
Completed op-code send to EA routine

Sends 6 bits through the right most bits in register D0.W
D1.B is utilized to flag source or destinate <ea>. D1.B = 0 is source,
D1.B = 1 is destination