document many more cooincidental similarities with C64 ROMs

strings/000005

@@ -0,0 +1,3 @@
+$05 byte after some leading $00s
+
+Not creative. Not copyrightable.

strings/00000800

@@ -0,0 +1,3 @@
+A single $08 byte in a field of $00's
+
+Nothing creative or copyrightable here.

strings/00029900

@@ -0,0 +1 @@
+fragments of instructions. Not copyrightable.

strings/00DD09

@@ -0,0 +1,6 @@
+Do something with $DD00 and compare it with some value.
+
+$DD00 is one of the CIA ports, so checking the value of inputs
+on this port is something rather expected and common.
+Also, this sequence doesn't even contain a whole instruction.
+Not copyrightable.

strings/00DD09088D00DD

@@ -0,0 +1,6 @@
+Set a bit in $DD00
+
+See other notes on bit manipulations of $DD00.
+Manipulating bits in a bit is not creative or copyrightable.
+Also, $DD00 is an IO register, which is expected to suffer
+such bit manipulations.

strings/00DD60AD00DD29

@@ -0,0 +1,5 @@
+Do something with $DD00, return from subroutine. Do something else with $DD00
+
+$DD00 is an IO register of a CIA in the C64 associated with the disk drive port.
+Thus having routines that do things with it is expected and necessary.
+The sequence here has nothing creative nor is it in our view copyrightable.

strings/00DDAD

@@ -0,0 +1,6 @@
+Do something with $DD00, then read something from memory. Only instruction fragments.
+
+No whole instructions here.
+$DD00 is a CIA IO register on the C64, so doing things with it is rather necessary.
+Loading from memory is also intrinsic to operation of a processor.
+Nothing creative. Nothing copyrightable.

strings/026078

@@ -0,0 +1,6 @@
+Fragment, RTS, Disable interrupts. Fragment of end and start of routines.
+
+Neither returning from a subroutine nor disabling interrupts is
+notable or copyrightable.  One in 256 routines would be expected
+to result in this sequence by pure chance.  
+Nothing creative or copyrightable.

strings/034CED

@@ -0,0 +1,3 @@
+Fragment of JMP instruction.
+
+Only fragments of instructions. Not creative nor copyrightable.

strings/071869

@@ -0,0 +1,5 @@
+Fragment + CLC + ADC fragment.
+
+Fragment of an addition pattern.
+Nothing creative nor copyrightable.
+Also only one whole instruction.

strings/087820

@@ -0,0 +1,4 @@
+fragment + SEI + JSR fragment
+
+Only a single whole instruction.
+Not copyrightable.

strings/0878820

@@ -0,0 +1,4 @@
+SEI surrounded by instruction fragments.
+
+Single whole insstruction.
+Not creative. Not copyrightable.

strings/09088D

@@ -0,0 +1,4 @@
+Or A register with $08 and store result somewhere.
+
+Simple bit manipulation and memory access.
+Not creative or copyrightable.

strings/09108D00DD60AD00DD

@@ -0,0 +1,6 @@
+set a bit in $DD00, Return from subroutine, read $DD00
+
+$DD00 is a key IO register for the IEC serial port.
+Thus it is no surprise to find routines that manipulate $DD00,
+and indeed for them to appear one after the other.
+Nothing creative. Not copyrightable.

strings/09208D00DD

@@ -0,0 +1,6 @@
+Set a bit in $DD00.
+
+Again, $DD00 is a register that is used for the IEC serial interface.
+Clearing and setting bits in it is required to implement the protocol.
+Also, clearing and setting bits in a memory location is not creative
+or copyrightable.

strings/09A90085

@@ -0,0 +1,5 @@
+Fragment + store $00 somewhere into ZP.
+
+Writing to a memory location with a specific value
+is neither creative nor copyrightable.
+

strings/0DDC68A868AA6840A900

@@ -0,0 +1,9 @@
+Tail end of standard CIA-triggered interrupt, followed by start of another routine
+
+LDA $DC0D is the standard way to clear interrupt status on the 6526 CIA.
+Then we have the standard return from interrupt sequence for a 6502
+(see the wikipedia page on 6502 interrupts, for example), followed by 
+loading A with $00 at the start of a following routine -- which is a not
+uncommon way for routines to start.
+
+In short, nothing creative nor copyrightable.

strings/1860A5

@@ -0,0 +1,5 @@
+CLC RTS + instruction fragment.
+
+i.e., return success from a routine, and then whatever follows.
+Better than 1 in 256 routines can be expected to exhibit this
+sequence simply through chance.

strings/1860A90085

@@ -0,0 +1,4 @@
+Return from routine with success, Store $00 somewhere in ZP.
+
+End of routine fragment followed by the start of a routine that
+stores 0 somewhere.  Not creative. Not copyrightable.

strings/1860AD

@@ -0,0 +1,11 @@
+CLC / RTS / JSR $xxxx
+
+CLC / RTS the obvious and simplest way to clear the carry flag
+when returing from a routine.  Many of the routines in the C64 KERNAL
+public API indicate that they use the carry flag to indicate success
+or failure, hence how often it shows up in the C64 KERNAL itself.
+That a JSR instruction happens to be the first instruction in whatever
+follows actually highly likely through chance, since several percent
+of all instructions in a typical 6502 program are JSR instructions.
+
+Not copyrightable.

strings/20A3FD20

@@ -0,0 +1,4 @@
+JSR $FDA3 (SCAN KEYBOARD) , JSR somewhere else
+
+$FDA3 is listed on p238 of Compute's Mapping the 64
+and thus calling it is totally expected.

strings/29EF09

@@ -0,0 +1,4 @@
+Clear a bit in A and do something with it.
+
+Only one whole instruction.
+Not creative. Not copyrightable.

strings/29F78D

@@ -0,0 +1,5 @@
+clear a bit and store result some where.
+
+Only one whole instruction.
+Manipulating bits in bytes is bread and butter of CPUs.
+Nothing creative nor copyrightable.

strings/30034C

@@ -0,0 +1,5 @@
+Conditionally JMP somewhere.
+
+Would be single instruction on many architectures.
+Not copyrightable. Not creative.
+Only one whole instruction.

strings/3860A5

@@ -0,0 +1,5 @@
+SEC + RTS + fragment of next routine
+
+C flag is used to report success or failure of routines.
+This is an example of a routine fragment for returning failure.
+Not creative nor copyrightable.

strings/38E901

@@ -0,0 +1,5 @@
+SEC / SBC #$01 - subtract 1 from A.
+
+Would be single instruction on many architectures.
+Is simple and common register manipulation.
+Nothing creative. Not copyrightable.

strings/4C4F4144494E

@@ -0,0 +1 @@
+The string "LOADIN", part of LOADING. Not copyrightable.

strings/4F5220

@@ -0,0 +1,3 @@
+"OR " string, being part of "ERROR "
+
+Not copyrightable.

strings/534541524348494E47

@@ -0,0 +1 @@
+The string "SEARCHING". Not copyrightable.

strings/586C00A0

@@ -0,0 +1,4 @@
+Clear C, jump into BASIC ROM to start BASIC.
+
+Simplest and most obvious way to achieve this action,
+as required for a C64 to boot.

strings/607820

@@ -0,0 +1,5 @@
+RTS / SEI / JSR somewhere
+
+End and start of routines fragment.
+Nothing creative. Not copyrightable.
+

strings/60AD00DD29EF

@@ -0,0 +1,5 @@
+Return from sub-routine, clear a bit in $DD00
+
+See other commentary on IO port $DD00 and the reasonableness
+of seeing routines that manipulate bits in it.
+Not creative. Not copyrightable.

strings/68AA6840

@@ -0,0 +1,6 @@
+PLA / TAX / PLA / RTI
+
+Pop A and X registers from the stack and return from interrupt.
+Standard end of interrupt sequence on 6502.
+See, for example, https://en.wikipedia.org/wiki/Interrupts_in_65xx_processors
+Not copyrightable.

strings/A4C218

@@ -0,0 +1,3 @@
+Load Y from ZP. Clear carry flag. Simple register manipulations.
+
+Not creative. Not copyrightable.

strings/A868AAA5

@@ -0,0 +1,3 @@
+Restore Y and X from stack, load A from somewhere.
+
+Simple register manipulation. Not creative nor copyrightable.

strings/C4B7F00C

@@ -0,0 +1,4 @@
+take a branch based on comparison of Y register and memory.
+
+Changing program flow based on the result of a comparison is 
+a very common programming pattern

strings/C8C004D0

@@ -0,0 +1,5 @@
+branch based on whether X register holds the number 4.
+
+Loop fragment.
+Nothing creative.
+No copyrightable.

strings/CAD0F560

@@ -0,0 +1,4 @@
+End of loop fragment (branch backwards based on X, then return when done).
+
+Not creative.
+Not copyrightable.

strings/D2FFC8C0

@@ -0,0 +1 @@
+fragment of string printing loop (JSR $FFD2 / INX / CPX ... )

strings/DCAD0DDCA9

@@ -0,0 +1,4 @@
+Read from $DC0D to clear CIA interrupts, surrounded by instruction fragments.
+
+This is the method for clearing CIA interrupts.
+Not creative or copyrightable.

strings/DD29F78D00DD

@@ -0,0 +1,5 @@
+clear a bit in $DD00
+
+Yet another fragment of bit manipulation for the CIA register $DD00
+that is used to communicate with the disk drive port.
+Clearing specific bits in bytes is not creative nor copyrightable.

strings/DD60AD00DD29

@@ -0,0 +1,7 @@
+do something with $DD00, then RTS, then read $DD00
+
+Again, $DD00 is a CIA IO register, and so there are a number 
+of routines that are required that simply check or modify the
+contents of this register in order to implement the IEC serial
+protocol.  Thus it is totally unsurprising to find routines that
+start by reading $DD00 and then processing it in some way.

strings/EA20A0E5

@@ -0,0 +1,10 @@
+instruction fragment followed by JSR to VIC-II register setup.
+
+$E5A0 is documented in Compute's Mapping the 64 on p216 as
+the correct location for this routine, so it is no surprise to
+find a call there.
+Not creative. Not copyrightable.
+
+The leading $EA which is a NOP in the C64 KERNAL is a good example
+of purely cooincidental matches, as in our ROM it is the high-byte
+of an argument to the preceeding instruction.

strings/EC140D1D8885868711335741345A5345

@@ -0,0 +1,16 @@
+List of key codes generated when certain key combinations are pressed
+
+This sequence is a list of which ASCII/PETSCII code should be generated
+when certain key combinations are pressed, based on the keyboard matrix
+position.  That is, it is a sequence in keyboard matrix order, of the
+codes that should be generated. Thus it is a list of facts, which cannot
+be copyright, according to the long standing precedent under US copyright law:
+
+https://www.law.cornell.edu/copyright/cases/499_US_340.htm
+
+Similar decisions exist in other jurisidctions.
+
+Note also that the matrix order list of keys is a fact of the C64 hardware,
+and which has been repeated in many publications, such as Compute's Mapping the 64,
+without challenge from the C64 ROM copyright owners, which serves to reinforce the
+claim that this sequence of bytes is not copyrightable.

strings/F0021860

@@ -0,0 +1,3 @@
+conditionally execute CLC + RTS, i.e., conditionally return success from a routine.
+
+Nothing creative or copyrightable here.

strings/FFD0034C

@@ -0,0 +1,4 @@
+fragment / BNE <skip following JMP instruction> / JMP somewhere
+
+Conditionally jump somewhere.  Would be a single instruction
+on many architectures.  Not copyrightable.