anchor.diff:  ^AE 17
   ^AE 15
   ^AE 12
  +----
   
   Because we would have done 15 first, then when we would have done 17,
   it would have gone to before the line.
   
  -So we see that to fastpatch a D, we need to stop at either the data line
  -of interest or a D with a bigger serial.
  -
  -Likewise of the 'E' commands closing the D, we see that our E15 doesn't
  -go right after the token but is also in a sorted order of E's.  The rule
  +So we see that to fastpatch a `D`, we need to stop at either the data line
  +of interest or a `D` with a bigger serial.
  +
  +Likewise of the `E` commands closing the `D`, we see that our `E15` doesn't
  +go right after the token but is also in a sorted order of `E`'s.  The rule
   for moves after a token is a little more complex:
   
   Move to after the token, then move stopping before:
  -An I or E of lower serial number.
  -A data line not in an I .. E block of higher serial which is being skipped.
  -Any D not in an I .. E block of higher serial being skipped.
  -
  -In the above case, the E15 being woven goes after the "line one" token,
  -and sees a E17 next, which is a larger serial, so it skips it, and sees
  -a E12, so it writes itself out there.
  -
  -What if we want to put an E15 into this:
  -
  +An `I` or `E` of lower serial number.
  +A data line not in an `I .. E` block of higher serial which is being skipped.
  +Any `D` not in an `I .. E` block of higher serial being skipped.
  +
  +In the above case, the `E15` being woven goes after the "line one" token,
  +and sees a `E17` next, which is a larger serial, so it skips it, and sees
  +a `E12`, so it writes itself out there.
  +
  +What if we want to put an `E15` into this:
  +
  +----
   ^AI 12
   ^AD 15
   ^AD 17
  
positive.code: ^AE 21
  ^AE 16
  ^AE 12
  
  using the rules, we hit the I16, it's bigger, so we skip it, and not
  only skip it, but remember it and ignore everything until E16.  While
  D lines normally mean stop, they are skipped inside a skipblock.  Same
  goes for the data line "some new line since deleted".  When we get
  to the E16, we start doing the rules again, seeing the next line is
  E12, we put our E15 there:
  
  ^AI 12
  ^AD 15
  ^AD 17
  
negative.code: 
  Along the same lines, the only empty data block to be encoded is an
  empty new file.  It is this way because a new file is basically:
  ----
  printf("\001I 2\n");
  system("cat file");
  printf("\001E 2\n");
  printf("\001I 1\n");
  printf("\001E 1\n");
  ----
  The `I-E` pair could have been skipped by seeing that the data file was
  zero size.
  
  === diff -an
  
  Most modern version control systems (not git) can be built on the
  output of "diff -an old new".  This is the RCS version of diff,
  though RCS on the trunk does "diff -an new old".
  
  Example: we add a new line to the start:
  
  ----
  new line
  line 1
  line 2
  line 3
  ----
  
  diff -an output:
  
  ----
  a0 1
  new line
  ----
  
  The weave function
  (http://www.bkbits.net/u/bk/bugfix/src/slib.c?PAGE=anno[`slib.c:delta_body()`]) 
  reads that as "go after line 0,
  and add one line.  Line 0 is the start of the file.  The new weave
  then looks like:
  
  ----
  ^AI 3
  new line
  ^AE 3
  ^AI 2
  line 1
  line 2
  line 3
  ^AE 2
  ^AI 1
  ^AE 1
  ----
  
  Let's do it again.  Add a line after our new line:
  ----
  new line
  another new line
  line 1
  line 2
  line 3
  ----
  
  `diff -an` output:
  ----
  a1 1
  another new line
  ----
  
  Weave:
  ----
  ^AI 3
  new line
  ^AI 4
  