anchor.diff:  ^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
  +----
  +
  +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:
  -
  +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
  
positive.code: ^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
  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:
  
  ^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
  