anchor.diff:  %%     If = fun ([Ctest], _, _, St) ->
   %%          True = c_atom(true),
   %%          False = c_atom(false),
  -%%          Ctrue = c_clause([True], True, Ctr, [L]),
  -%%          Cfalse = c_clause([Fail], True, Cfa, [L]),
  +%%          Ctrue = c_clause([L], [True], Ctr),
  +%%          Cfalse = c_clause([L], [Fail], Cfa),
   %%          Cfail = if_fail(L, St),
  -%%          {c_case(Ctest, [Ctrue,Cfalse,Cfail], [L]),St}
  +%%          {c_case([L], Ctest, [Ctrue,Cfalse,Cfail]),St}
   %%      end,
   %%     simple_seq([Cte], If, Env, L, St3).
   
  
positive.code: %% pattern with a list!
  
  comp_match_clause([Pats|Body], Env0, L, St0) ->
      {Cps,{Pvs,St1}} = mapfoldl(fun (P, {Psvs,Sta}) ->
                         {Cp,Pvs,Stb} = pattern(P, L, Sta),
                         {Cp,{union(Pvs, Psvs),Stb}}
                     end, {[],St0}, Pats),
      Env1 = add_vbindings(Pvs, Env0),
      {Cg,Cb,St2} = comp_clause_body(Body, Env1, L, St1),
      {c_clause(Cps, Cg, Cb, [L]),St2}.
  
  %% comp_let(VarBindings, Body, Env, L, State) -> {#c_let{}|#c_case{},State}.
  %% Compile a let expr. We are a little cunning in that we specialise
  
negative.code: comp_bitsegs([Vsp|Segs], Csegs, Env, L, St0) ->
      {Cval,Csize,Un,Ty,Fs,St1} = comp_bitseg(Vsp, Env, L, St0),
      %% Sequentialise Val and Size if necessary, then do rest
      Next = fun ([Cv,Csz], En, Li, St) ->
                     Cs = c_bitseg(Cv, Csz, Un, Ty, Fs),
                     comp_bitsegs(Segs, [Cs|Csegs], En, Li, St)
             end,
      simple_seq([Cval,Csize], Next, Env, L, St1);
  comp_bitsegs([], Csegs, _, L, St) ->
      {c_binary([L], reverse(Csegs)),St}.
  
  %% comp_bitseg(ValSpec, Env, Line, State) -> {Cval,Csize,Unit,Type,Fs,State}.
  %% Need to handle some special cases.
  