anchor.diff:  split(U) ->
       U.
   
  +%% unpack until we got [ binary(), ..., binary(), { muta, meta } ]
  +%% TODO: move to utils?
  +-spec prepare4sizer(list(any())) -> {binary(), any()}.
  +prepare4sizer(L) -> 
  +    Res = prepare4sizer(L, []),
  +    %io:format("~p~n", [Res]),
  +    Res.
  +
  +-spec prepare4sizer(list(any()), list()) -> {binary(), any()}.
  +prepare4sizer([T], Acc) when is_list(T) -> 
  +    prepare4sizer(T, Acc);
  +prepare4sizer([H|T], Acc) when is_binary(H) -> 
  +    prepare4sizer(T, [H|Acc]);
  +prepare4sizer([H|T], Acc) when is_function(H) -> 
  +    prepare4sizer([H()|T], Acc);
  +prepare4sizer(H, Acc) -> 
  +    {erlang:iolist_to_binary(lists:reverse(Acc)), H}.
  +
  +%%TODO: fix spec
  +-spec mutate_once_sizer(binary(), any(), any(), integer(), mutator(), 
  +                        meta_list(), mutator_cont_fun()) -> list().
  +mutate_once_sizer(Binary, [], Rest, Ip, Mutator, Meta, NextPat) ->
  +    %% do nothing, go for next pattern
  +    SizerMeta = [{sizer, failed} | Meta],
  +    {This, LlN} = split({Binary, Rest}),
  +    if
  +        This /= false ->
  +            mutate_once_loop(Mutator, SizerMeta, NextPat, Ip, This, LlN);
  +        true ->
  +            NextPat([], Mutator, SizerMeta)
  +    end;
  +mutate_once_sizer(Binary, Elem = {ok, Size, Len, A, _B}, Rest, Ip, Mutator, Meta, NextPat) ->
  +    Am8 = A * 8, Len8 = Len * 8,
  +    <<H:Am8, Len:Size, Blob:Len8, TailBin/binary>> = Binary,
  +    {This, LlN} = split({<<Blob:Len8>>, Rest}),
  +    SizerMeta = [{sizer, Elem} | Meta],
  +    {NewBlob, RestLst} = prepare4sizer(mutate_once_loop(Mutator, SizerMeta, NextPat, Ip, This, LlN)),
  +    NewLen = size(NewBlob),
  +    %io:format(standard_error, "~nNewLen = ~p/~p/~p/~p~n", [NewLen, NewBlob, TailBin, RestLst]),
  +    NewBin = <<H:Am8, NewLen:Size, NewBlob/binary>>,
  +    [NewBin, TailBin | RestLst].
  +
  +%% mutate_once for sizer pattern
  +-spec mutate_once_sizer(any(), mutator(), meta_list(), mutator_cont_fun()) -> list().
  +mutate_once_sizer(Ll, Mutator, Meta, NextPat) -> 
  +    Ip = erlamsa_rnd:rand(?INITIAL_IP),
  +    {Bin, Rest} = erlamsa_utils:uncons(Ll, false),
  +    Elem = erlamsa_rnd:rand_elem(erlamsa_len_predict:get_possible_simple_lens(Bin)),
  +    %io:format("Elem = ~p~n", [Elem]),
  +    mutate_once_sizer(Bin, Elem, Rest, Ip, Mutator, Meta, NextPat).
  +
  +%% mutate_once for skipper pattern
   -spec mutate_once_skipper(any(), mutator(), meta_list(), mutator_cont_fun()) -> list().
  -mutate_once_skipper(Ll, Mutator, Meta, Cont) -> 
  +mutate_once_skipper(Ll, Mutator, Meta, NextPat) -> 
       Ip = erlamsa_rnd:rand(?INITIAL_IP),
       {Bin, Rest} = erlamsa_utils:uncons(Ll, false),
       Len = erlamsa_rnd:rand(floor(size(Bin)/2))*8,
  
positive.code:         patterns()),
      mux_patterns(Pats).
  
  %% [{Pri, Pat}, ...] -> fun(rs, ll, muta, meta) .. pattern_output .. end
  -spec mux_patterns([pattern()]) -> fun((any(), mutator(), meta_list()) -> list()).
  mux_patterns(Patterns) ->
      {SortedPatterns, N} = erlamsa_utils:sort_by_priority(Patterns),
      fun(Ll, Muta, Meta) ->
          RIdxPs = erlamsa_rnd:rand(N),
          PatF = erlamsa_utils:choose_pri(SortedPatterns, RIdxPs),
          PatF(Ll, Muta, Meta)
      end.
negative.code:     SkipperMeta = [{skipped, Len/8} | Meta],
      Res =   if
                  This /= false ->
                      mutate_once_loop(Mutator, SkipperMeta, NextPat, Ip, This, LlN);
                  true ->
                      [{Mutator, SkipperMeta}]
              end,
      [<<HeadBin:Len>>| Res].
  
  