anchor.diff:  gen_part_decode_funcs(WhatKind,_TypeName,{_,Directive,_,_}) ->
       throw({error,{asn1,{"Not implemented yet",WhatKind," partial incomplete directive:",Directive}}}).
   
  -
  -gen_types(Erules,Tname,{RootL1,ExtList,RootL2}) 
  +%% EncDec = 'gen_encode' | 'gen_decode'
  +gen_types(Erules, Tname, {RootL1,ExtList,RootL2}, EncDec)
     when is_list(RootL1), is_list(RootL2) ->
  -    gen_types(Erules,Tname,RootL1),
  +    gen_types(Erules, Tname, RootL1, EncDec),
       Rtmod = ct_gen_module(Erules),
  -    gen_types(Erules,Tname,Rtmod:extaddgroup2sequence(ExtList)),
  -    gen_types(Erules,Tname,RootL2);
  -gen_types(Erules,Tname,{RootList,ExtList}) when is_list(RootList) ->
  -    gen_types(Erules,Tname,RootList),
  +    gen_types(Erules, Tname, Rtmod:extaddgroup2sequence(ExtList), EncDec),
  +    gen_types(Erules, Tname, RootL2, EncDec);
  +gen_types(Erules, Tname, {RootList,ExtList}, EncDec) when is_list(RootList) ->
  +    gen_types(Erules, Tname, RootList, EncDec),
       Rtmod = ct_gen_module(Erules),
  -    gen_types(Erules,Tname,Rtmod:extaddgroup2sequence(ExtList));
  -gen_types(Erules,Tname,[{'EXTENSIONMARK',_,_}|Rest]) ->
  -    gen_types(Erules,Tname,Rest);
  -gen_types(Erules,Tname,[ComponentType|Rest]) ->
  +    gen_types(Erules, Tname, Rtmod:extaddgroup2sequence(ExtList), EncDec);
  +gen_types(Erules, Tname, [{'EXTENSIONMARK',_,_}|T], EncDec) ->
  +    gen_types(Erules, Tname, T, EncDec);
  +gen_types(Erules, Tname, [ComponentType|T], EncDec) ->
  +    asn1ct_name:clear(),
       Rtmod = ct_gen_module(Erules),
  +    Rtmod:EncDec(Erules, Tname, ComponentType),
  +    gen_types(Erules, Tname, T, EncDec);
  +gen_types(_, _, [], _) ->
  +    ok;
  +gen_types(Erules, Tname, #type{}=Type, EncDec) ->
       asn1ct_name:clear(),
  -    Rtmod:gen_encode(Erules,Tname,ComponentType),
  -    asn1ct_name:clear(),
  -    Rtmod:gen_decode(Erules,Tname,ComponentType),
  -    gen_types(Erules,Tname,Rest);
  -gen_types(_,_,[]) ->
  -    true;
  -gen_types(Erules,Tname,Type) when is_record(Type,type) ->
       Rtmod = ct_gen_module(Erules),
  -    asn1ct_name:clear(),
  -    Rtmod:gen_encode(Erules,Tname,Type),
  -    asn1ct_name:clear(),
  -    Rtmod:gen_decode(Erules,Tname,Type).
  +    Rtmod:EncDec(Erules, Tname, Type).
   
   %% VARIOUS GENERATOR STUFF 
   %% *************************************************
  
positive.code: 	'SET' ->
  	    Rtmod:gen_encode_set(Erules,Typename,D),
  	    #'SET'{components=Components} = D#type.def,
  	    gen_types(Erules,Typename,Components);
  	'SEQUENCE' ->
  	    Rtmod:gen_encode_sequence(Erules,Typename,D),
  	    #'SEQUENCE'{components=Components} = D#type.def,
  	    gen_types(Erules,Typename,Components);
  	'CHOICE' ->
  	    Rtmod:gen_encode_choice(Erules,Typename,D),
  	    {_,Components} = D#type.def,
  	    gen_types(Erules,Typename,Components);
  	'SEQUENCE OF' ->
  	    Rtmod:gen_encode_sof(Erules,Typename,InnerType,D),
  	    {_,Type} = D#type.def,
  	    NameSuffix = asn1ct_gen:constructed_suffix(InnerType,Type#type.def),
  	    gen_types(Erules,[NameSuffix|Typename],Type);
  	'SET OF' ->
  	    Rtmod:gen_encode_sof(Erules,Typename,InnerType,D),
  	    {_,Type} = D#type.def,
  	    NameSuffix = asn1ct_gen:constructed_suffix(InnerType,Type#type.def),
  	    gen_types(Erules,[NameSuffix|Typename],Type);
  	_ ->
  	    exit({nyi,InnerType})
      end;
  
negative.code:     asn1ct:step_in_constructed(), %% updates namelist for exclusive decode
      case InnerType of
  	'SET' ->
  	    Rtmod:gen_decode_set(Erules,Typename,D),
  	    #'SET'{components=Components} = D#type.def,
  	    gen_types(Erules, Typename, Components, gen_decode);
  	'SEQUENCE' ->
  	    Rtmod:gen_decode_sequence(Erules,Typename,D),
  	    #'SEQUENCE'{components=Components} = D#type.def,
  	    gen_types(Erules, Typename, Components, gen_decode);
  	'CHOICE' ->
  	    Rtmod:gen_decode_choice(Erules,Typename,D),
  	    {_,Components} = D#type.def,
  	    gen_types(Erules, Typename, Components, gen_decode);
  	'SEQUENCE OF' ->
  	    Rtmod:gen_decode_sof(Erules,Typename,InnerType,D),
  	    {_,#type{def=Def}=Type} = D#type.def,
  	    NameSuffix = asn1ct_gen:constructed_suffix(InnerType, Def),
  	    gen_types(Erules, [NameSuffix|Typename], Type, gen_decode);
  	'SET OF' ->
  	    Rtmod:gen_decode_sof(Erules,Typename,InnerType,D),
  	    {_,#type{def=Def}=Type} = D#type.def,
  	    NameSuffix = asn1ct_gen:constructed_suffix(InnerType, Def),
  	    gen_types(Erules, [NameSuffix|Typename], Type, gen_decode)
      end;
  
  gen_decode_constructed(Erules,Typename,InnerType,D) when is_record(D,typedef) ->
      gen_decode_constructed(Erules,Typename,InnerType,D#typedef.typespec).
  