add more explanations of byte sequences.

strings/026090

@@ -0,0 +1,16 @@
+End of routine fragment
+
+The three instances of this in the C64 KERNAL are something like:
+
+XXX $02xx
+RTS
+Bxx $xxxx
+
+Each time it does something different, which emphasises that this 
+is a piece of simple machinery that can occur by chance, especially
+when variables are stored in the area $0200 - $02FF, which is common.
+For example, the BBC micro uses this area in this way:
+http://8bs.com/mag/32/bbcmemmap1.txt
+
+In any case, such a short sequence devoid of independent meaning is
+not copyrightable. 

strings/036C140320

@@ -0,0 +1,22 @@
+Jump to routine at vector $0314
+
+This corresponds to
+
+Bxx +
+JMP ($0314)
+*
+JSR $xxxx
+
+That is, based on the result of some branch instruction, 
+optionally jump to the routine whose address is stored in
+$0314 - $0315.
+The use of a jump table is not copyrightable of itself.
+The location of jump table vectors at $0314 on the C64 is publicly
+documented.  
+There are also unrelated systems using jumptables with the constant
+$0314, e.g.:
+https://github.com/mamedev/mame/blob/master/src/mame/drivers/mosaic.cpp
+http://www.microchip.com/forums/download.axd?file=1;895201
+
+In short, there is absolutely no reason to be able to even entertain
+copyrighting jumping through a vector at $0314.

strings/118D0EDC

@@ -0,0 +1,12 @@
+Do something with $11, then write to $DC0E
+
+This is probably the tail end of something like:
+
+LDA #$11
+STA $DC0E
+
+Putting a value into a memory location is not copyrightable.
+
+$DC0E is one of the control registers for a 6526 CIA on
+the Commodore 64, and thus writing to it is totally normal
+and expected.

strings/8D00DDA9

@@ -0,0 +1,12 @@
+Store something in $DD00, then load something into the A register
+
+STA $DD00
+LDA #$xx
+
+Writing to a memory location is not copyrightable.
+Loading something into the A register happens very frequently.
+Thus the only non-random thing about this pair of instructions
+is that the C64 has an important IO register at $DD00, which
+makes it much more likely that such a sequence will occur as
+a random part of writing programs.  It is in any case not
+copyrightable.

strings/A97F8D0DDC

@@ -0,0 +1,10 @@
+Clear CIA1 interrupt status
+
+LDA #$7F
+STA $DC0D
+
+This is a well known sequence for clearing CIA1 interrupts
+on the C64.
+It is the simplest implementation to write $7F into location
+$DC0D.
+For each of these reasons it cannot be subject to copyright.

strings/AE8102AC8202

@@ -0,0 +1,15 @@
+Load X and Y from pointer at $0281
+
+LDX $0281
+LDY $0282
+
+Loading two registers from two successive memory locations
+is not copyrightable.
+
+On the C64, these locations typically hold the start of memory
+pointer, thus even if the sequence were somehow copyrightable,
+which we do not admit, it is an obvious and expected sequence
+whenever one wishes to load the start of memory pointer into 
+registers to be worked with.  Thus it must be held to be both
+fair use and exempt under interoperability provisions in various
+copyright acts, if the defence were required.

strings/AE8302AC8402

@@ -0,0 +1,15 @@
+Load X and Y from pointer at $0283
+
+LDX $0283
+LDY $0284
+
+Loading two registers from two successive memory locations
+is not copyrightable.
+
+On the C64, these locations typically hold the top of memory
+pointer, thus even if the sequence were somehow copyrightable,
+which we do not admit, it is an obvious and expected sequence
+whenever one wishes to load the start of memory pointer into 
+registers to be worked with.  Thus it must be held to be both
+fair use and exempt under interoperability provisions in various
+copyright acts, if the defence were required.