cand_cond.tmp.u:	local	5,000000,mknode
coerce.tmp.u:	local	9,000000,mknode
cor_cond.tmp.u:	local	5,000000,mknode
djd2:Parsing stree/mknode.tmp.icn: ...................................................................................................................................................
djd2:stree/mknode.tmp.icn:
djd2:  mknode
#djd2.tmp#:Parsing stree/mknode.tmp.icn: .....................................................................................................................................................
#djd2.tmp#:stree/mknode.tmp.icn:
#djd2.tmp#:  mknode
djd2.tmp:Parsing stree/mknode.tmp.icn: .......................................................................................................................................................
djd2.tmp:stree/mknode.tmp.icn:
djd2.tmp:  mknode
djd.insrt:pass1/parser/grammar.fixed.icn:		yyval := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
djd.insrt:pass1/parser/grammar.y:		$$ = insrtptr = mknode(BLOCKDENOTATION,emptylist(),NIL);
djd.insrt:pass1/parser/grammar.icn:		yyval := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
djd.insrt:pass1/parser/grammar.edit.y:		$$ := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
djd.insrt:pass1/parser/grammar.orig.c.y:		$$ = insrtptr = mknode(BLOCKDENOTATION,emptylist(),NIL);
djd.insrt:pass1/parser/grammar.indent.y:		$$ := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
djd.tmp:/home/dennis/src/lang/unicon/unicon/unicon/bin/icont -c  -fs -fs -u  -O stree/mknode.tmp.icn /tmp/uni13024414
djd.tmp:stree/mknode.tmp.icn succeded
djd.tmp:/home/dennis/src/lang/unicon/unicon/unicon/bin/icont  -o ./russell  globals_init.tmp.u main.tmp.u mine.tmp.u scan.tmp.u grammar.fixed.tmp.u initids.tmp.u precedence.tmp.u stt.tmp.u RIC.tmp.u ststructs_cls.tmp.u mknode.tmp.u mkappl.tmp.u Array.tmp.u mkappl2.tmp.u outermost_op.tmp.u single_arg.tmp.u cand_cond.tmp.u cor_cond.tmp.u sig_out.tmp.u sig_in.tmp.u add_id.tmp.u process_id.tmp.u restore.tmp.u retrieve.tmp.u fixup.tmp.u number.tmp.u reorder.tmp.u sigids.tmp.u checksigs.tmp.u findsig.tmp.u codegen.tmp.u drefops.tmp.u analyze.tmp.u accessible.tmp.u bld_analyze.tmp.u decl_sort.tmp.u allocate.tmp.u gden_order.tmp.u tsig_order.tmp.u findapplsig.tmp.u coerce.tmp.u fixhints.tmp.u build_symtab.tmp.u
ee:echo "9 mknode"
ee:9)  emacs stree/mknode.c stree/mknode.icn;;
ee:echo "9 mknode"
#ee#:echo "9 mknode"
#ee#:9)  emacs stree/mknode.c stree/mknode.icn;;
#ee#:echo "9 mknode"
ee~:echo "9 mknode"
ee~:9)  emacs stree/mknode.c stree/mknode.icn;;
ee~:echo "9 mknode"
eee:echo "9 mknode"
eee:9)  emacs stree/mknode.c stree/mknode.icn;;
eee:echo "9 mknode"
eee~:echo "9 mknode"
eee~:9)  emacs stree/mknode.c stree/mknode.icn;;
eee~:echo "9 mknode"
eeeee:echo "9 mknode"
eeeee:9)  emacs stree/mknode.c stree/mknode.icn;;
eeeee:echo "9 mknode"
#eeeee#:echo "9 mknode"
#eeeee#:9)  emacs stree/mknode.c stree/mknode.icn;;
#eeeee#:echo "9 mknode"
eett:echo "9 mknode"
eett:9)  emacs stree/mknode.c stree/mknode.icn;;
eett:echo "9 mknode"
findapplsig.tmp.u:	local	35,000000,mknode
findsig.tmp.u:	local	76,000000,mknode
fixed_bugs:	      $$ = mknode(REXTERNDEF, read_signature($3), $3);
getprior:stree/ststructs_cls stree/mknode \
#getprior#:stree/ststructs_cls stree/mknode \
grammar.fixed.tmp.u:	local	2,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	4,000000,mknode
grammar.fixed.tmp.u:	local	2,000000,mknode
grammar.fixed.tmp.u:	local	4,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	10,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	6,000000,mknode
grammar.fixed.tmp.u:	local	6,000000,mknode
grammar.fixed.tmp.u:	local	2,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	5,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	5,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	5,000000,mknode
grammar.fixed.tmp.u:	local	4,000000,mknode
grammar.fixed.tmp.u:	local	4,000000,mknode
grammar.fixed.tmp.u:	local	3,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
grammar.fixed.tmp.u:	local	1,000000,mknode
hh:stree/mknode.tmp.icn.txt
hh.html:<li><a href="russell/share/stree/mknode.tmp.icn.txt" target="_blank">stree/mknode.tmp.icn.txt</a></li>
initids.tmp.u:	local	59,000000,mknode
make_extract_sig:cc -o ../extract_sig extract_sig.o stree/mknode.o stree/prstree.o stree/unparse.o sigio/sa_sig_in.o stree/drefops.o datatypes/consnodes.o pass5d/RIC.o vr.o stree/listops.o stree/kindname.o pass5d/op_codes.o pass1/stt/stt.o stree/bitcnt.o gc/gc.a
Makefile.main:stree/stree.o:  stree/mknode.o stree/listops.o stree/prstree.o stree/drefops.o stree/kindname.o stree/bitcnt.o stree/unparse.o
Makefile.main:	-ld -r -o stree/stree.o $(LFLAGS) stree/mknode.o stree/listops.o stree/prstree.o stree/drefops.o stree/kindname.o stree/bitcnt.o stree/unparse.o
Makefile.main:stree/mknode.o: $(stinclfiles)
mkappl2.tmp.u:	local	24,000000,mknode
mknode.tmp.u:uid	mknode.tmp.u1-1458956873-0
mknode.tmp.u:	250,000005,mknode,1
mknode.tmp.u:proc mknode
mknode.tmp.u:	filen	stree/mknode.tmp.icn
mknode.tmp.u:	local	2,000000,mknode
mm2:stree/mknode \
mm2:mknode.tmp.u \
#mm2#:stree/mknode \
#mm2#:mknode.tmp.u \
mm4:stree/mknode \
mm4:mknode.tmp.u \
mmtt:stree/mknode \
mmtt:mknode.tmp.u \
NOTES.gmr.edit.txt:#mknode & mklist - add [] s
pass1/applinfer/cor_cond.c:	return(mknode(GUARDEDLIST, emptylist()));
pass1/applinfer/cor_cond.c:    ge1 = mknode(GUARDEDELEMENT, first(d1), sel_true);
pass1/applinfer/cor_cond.c:    ge2 = mknode(GUARDEDELEMENT, mknode(WORDELSE), first(d2));
pass1/applinfer/cor_cond.c:    gl = mknode(GUARDEDLIST, mklist(ge1, ge2, -1));
pass1/applinfer/mkappl2.c:		    result = mknode(APPLICATION, *op, conc(left_arg,right_arg));
pass1/applinfer/mkappl2.c:			    result = mknode(APPLICATION, result,
pass1/applinfer/cand_cond.c:	return(mknode(GUARDEDLIST, emptylist()));
pass1/applinfer/cand_cond.c:    ge1 = mknode(GUARDEDELEMENT, first(d1), first(d2));
pass1/applinfer/cand_cond.c:    ge2 = mknode(GUARDEDELEMENT, mknode(WORDELSE), sel_false);
pass1/applinfer/cand_cond.c:    gl = mknode(GUARDEDLIST, mklist(ge1, ge2, -1));
pass1/applinfer/mkappl2.icn:		    result = mknode(APPLICATION, *op, conc(left_arg,right_arg));
pass1/applinfer/mkappl2.icn:			    result = mknode(APPLICATION, result,
pass1/applinfer/mkappl2.icn:	    result := mknode([APPLICATION,temp, conc(left_arg,right_arg)])
pass1/applinfer/mkappl2.icn:		result := mknode([APPLICATION, result,
pass1/applinfer/cand_cond.icn:	return(mknode(GUARDEDLIST, emptylist()))
pass1/applinfer/cand_cond.icn:    ge1 := mknode([GUARDEDELEMENT, d1.first(), d2.first()])
pass1/applinfer/cand_cond.icn:    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), sel_false])
pass1/applinfer/cand_cond.icn:    gl := mknode([GUARDEDLIST, mklist([ge1, ge2, -1])])
pass1/applinfer/#mkappl2.icn#:		    result = mknode(APPLICATION, *op, conc(left_arg,right_arg));
pass1/applinfer/#mkappl2.icn#:			    result = mknode(APPLICATION, result,
pass1/applinfer/#mkappl2.icn#:	    result := mknode([APPLICATION,temp_op, conc(left_arg,right_arg)])
pass1/applinfer/#mkappl2.icn#:		result := mknode([APPLICATION, result,
pass1/applinfer/cor_cond.tmp.icn:	return(mknode([GUARDEDLIST, emptylist()]))
pass1/applinfer/cor_cond.tmp.icn:    ge1 := mknode([GUARDEDELEMENT, d1.first(), sel_true])
pass1/applinfer/cor_cond.tmp.icn:    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), d2.first()])
pass1/applinfer/cor_cond.tmp.icn:    gl := mknode([GUARDEDLIST, mklist([ge1, ge2, -1])])
pass1/applinfer/cor_cond.icn:	return(mknode([GUARDEDLIST, emptylist()]))
pass1/applinfer/cor_cond.icn:    ge1 := mknode([GUARDEDELEMENT, d1.first(), sel_true])
pass1/applinfer/cor_cond.icn:    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), d2.first()])
pass1/applinfer/cor_cond.icn:    gl := mknode([GUARDEDLIST, mklist([ge1, ge2, -1])])
pass1/applinfer/mkappl2.tmp.icn:# 		    result = mknode(APPLICATION, *op, conc(left_arg,right_arg));
pass1/applinfer/mkappl2.tmp.icn:# 			    result = mknode(APPLICATION, result,
pass1/applinfer/mkappl2.tmp.icn:	    result := mknode([APPLICATION,temp, conc(left_arg,right_arg)])
pass1/applinfer/mkappl2.tmp.icn:		result := mknode([APPLICATION, result,
pass1/applinfer/cand_cond.tmp.icn:	return(mknode(GUARDEDLIST, emptylist()))
pass1/applinfer/cand_cond.tmp.icn:    ge1 := mknode([GUARDEDELEMENT, d1.first(), d2.first()])
pass1/applinfer/cand_cond.tmp.icn:    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), sel_false])
pass1/applinfer/cand_cond.tmp.icn:    gl := mknode([GUARDEDLIST, mklist([ge1, ge2, -1])])
pass1/parser/initids.c:        id_Boolean = mknode(LETTERID, indx_Boolean);
pass1/parser/initids.c:        id_Void = mknode(LETTERID, indx_Void);
pass1/parser/initids.c:	id_Integer = mknode(LETTERID, indx_Integer);
pass1/parser/initids.c:	id_put = mknode(LETTERID, indx_put);
pass1/parser/initids.c:	id_ValueOf = mknode(LETTERID, indx_ValueOf);
pass1/parser/initids.c:	id_New = mknode(LETTERID, indx_New);
pass1/parser/initids.c:	id_size = mknode(LETTERID, indx_size);
pass1/parser/initids.c:	id_Null = mknode(LETTERID, indx_Null);
pass1/parser/initids.c:	id_times = mknode(LETTERID, indx_times);
pass1/parser/initids.c:	id_plus = mknode(LETTERID, indx_plus);
pass1/parser/initids.c:        val_Boolean = lock( mknode(VALSIGNATURE,
pass1/parser/initids.c:	val_Integer = lock( mknode(VALSIGNATURE,
pass1/parser/initids.c:        val_Void    = lock( mknode(VALSIGNATURE,
pass1/parser/initids.c:        var_Void    = lock( mknode(VARSIGNATURE,
pass1/parser/initids.c:        val_param = lock( mknode(PARAMETER,
pass1/parser/initids.c:                                 mknode(VALSIGNATURE,
pass1/parser/initids.c:                                        mknode(LETTERID,-1)
pass1/parser/initids.c:        var_param = lock( mknode(PARAMETER,
pass1/parser/initids.c:                                 mknode(VARSIGNATURE,
pass1/parser/initids.c:                                        mknode(LETTERID,-1)
pass1/parser/initids.c:	sig_assign = lock( mknode(FUNCSIGNATURE, NIL /* inline */, as_params,
pass1/parser/initids.c:	    lock( mknode(FUNCSIGNATURE, NIL, two_params,
pass1/parser/initids.c:	    lock( mknode(FUNCSIGNATURE, NIL, two_params,val_Boolean) );
pass1/parser/initids.c:	sig_New = lock( mknode(FUNCSIGNATURE, NIL, emptylist(),
pass1/parser/initids.c:	sig_const = lock( mknode(FUNCSIGNATURE, NIL, emptylist(),
pass1/parser/initids.c:	sig_ValueOf = lock( mknode(FUNCSIGNATURE, NIL,
pass1/parser/initids.c:	sig_Signature = lock(mknode(SIGNATURESIG));
pass1/parser/initids.c:        sel_true = mknode(LETTERID,indx_true);
pass1/parser/initids.c:        sel_true = mknode(APPLICATION, sel_true, emptylist());
pass1/parser/initids.c:        sel_false = mknode(LETTERID,indx_false);
pass1/parser/initids.c:        sel_false = mknode(APPLICATION, sel_false, emptylist());
pass1/parser/initids.c:	appl_Null = mknode(APPLICATION, id_Null, emptylist());
pass1/parser/grammar.y:        {  $$ = mklist( mknode(PARAMETER,NIL,$1), -1 ); }
pass1/parser/grammar.y:	  $$ = mknode(VARSIGNATURE,$2);
pass1/parser/grammar.y:	  $$ = mknode(VALSIGNATURE,$2);
pass1/parser/grammar.y:	  $$ = mknode(TYPESIGNATURE,$11,$13,$5,$6,$7,$9);
pass1/parser/grammar.y:	  $$ = mknode(TYPESIGNATURE,$10,$12,$5,$6,$7,NIL);
pass1/parser/grammar.y:	  $$ = mknode(TYPESIGNATURE,$9,$11,$5,$6,$7,NIL);
pass1/parser/grammar.y:	  $$ = mknode(TYPESIGNATURE,$7,$9,$5,NIL,NIL,NIL);
pass1/parser/grammar.y:	  $$ = mknode(TYPESIGNATURE,$5,$7,NIL,NIL,NIL,NIL);
pass1/parser/grammar.y:	  $$ = mknode(TYPESIGNATURE,$2,$4,NIL,NIL,NIL,NIL);
pass1/parser/grammar.y:	  $$ = mknode(FUNCSIGNATURE,$3,$5,$7);
pass1/parser/grammar.y:	  $$ = mknode(FUNCSIGNATURE,$2,$4,$6);
pass1/parser/grammar.y:          vl_field_sig = mknode(FUNCSIGNATURE,
pass1/parser/grammar.y:                                mklist(mknode(PARAMETER,
pass1/parser/grammar.y:                                              mknode(VALSIGNATURE,
pass1/parser/grammar.y:                                                     mknode(LETTERID,-1))),
pass1/parser/grammar.y:                                mknode(VALSIGNATURE, $5));
pass1/parser/grammar.y:            vr_field_sig = mknode(FUNCSIGNATURE,
pass1/parser/grammar.y:                                  mklist(mknode(PARAMETER,
pass1/parser/grammar.y:                                                mknode(VARSIGNATURE,
pass1/parser/grammar.y:                                                       mknode(LETTERID,-1))),
pass1/parser/grammar.y:                                  mknode(VARSIGNATURE, $5));
pass1/parser/grammar.y:                        result = mknode(TSCOMPONENT,$1,sig_assign);
pass1/parser/grammar.y:                        result = mknode(TSCOMPONENT,$1,sig_less);
pass1/parser/grammar.y:                        result = mknode(TSCOMPONENT,$1,sig_greater);
pass1/parser/grammar.y:			result = mknode(TSCOMPONENT,$1,sig_equals);
pass1/parser/grammar.y:			result = mknode(TSCOMPONENT,$1,sig_sconc);
pass1/parser/grammar.y:			result = mknode(TSCOMPONENT,$1,sig_pconc);
pass1/parser/grammar.y:                        result = mknode(TSCOMPONENT,$1,sig_New);
pass1/parser/grammar.y:                        result = mknode(TSCOMPONENT,$1,sig_ValueOf);
pass1/parser/grammar.y:                        result = mknode(TSCOMPONENT,$1,sig_const);
pass1/parser/grammar.y:		$$ = mklist(mknode(DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3), -1);
pass1/parser/grammar.y:		$$ = insrtptr = mknode(BLOCKDENOTATION,emptylist(),NIL);
pass1/parser/grammar.y:        { $$ = mknode(WORDCAND); }
pass1/parser/grammar.y:        { $$ = mknode(WORDCOR); }
pass1/parser/grammar.y:	{ $$ = mknode(MODPRIMARY,$1,$2,NIL); }
pass1/parser/grammar.y:	      $$ = p = mknode(BLOCKDENOTATION,emptylist(),$2);
pass1/parser/grammar.y:        { $$ = mknode(GUARDEDLIST,$2); }
pass1/parser/grammar.y:        { $$ = mknode(LOOPDENOTATION,$2); }
pass1/parser/grammar.y:	  $$ = p = mknode(BLOCKDENOTATION,$2,$4);
pass1/parser/grammar.y:	  $$ = p = mknode(USELIST,$2,$4);
pass1/parser/grammar.y:	  $$ = mknode(REXTERNDEF, read_signature($3), $3);
pass1/parser/grammar.y:	      $$ = mknode(FUNCCONSTR,$1,first($3));
pass1/parser/grammar.y:	      $$ = mknode(FUNCCONSTR,$1,
pass1/parser/grammar.y:			      mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/grammar.y:	  $$ = mknode(FUNCCONSTR, $1, mknode(EXTERNDEF, $4));
pass1/parser/grammar.y:	  $$ = mknode(FUNCSIGNATURE, $3, $5, NIL);
pass1/parser/grammar.y:	{ $$ = mknode(FUNCSIGNATURE, $2, $4, NIL); }
pass1/parser/grammar.y:        { $$ = mknode(WORDELSE); }
pass1/parser/grammar.y:        { $$ = mknode(ENUMERATION,$3); }
pass1/parser/grammar.y:        { $$ = mknode(EXTENSION,$3); }
pass1/parser/grammar.y:	  $$ = mknode(PRODCONSTRUCTION,$2,$4); 
pass1/parser/grammar.y:        { $$ = mknode(RECORDCONSTRUCTION,$3); }
pass1/parser/grammar.y:          $$ = mknode(UNIONCONSTRUCTION,$2,$4);
pass1/parser/grammar.y:	{ $$ = mknode(WITHLIST,$2,$4); }
pass1/parser/grammar.y:	{ $$ = mknode($1,$2,$4);  }
pass1/parser/grammar.y:        { $$ = mknode(EXPORTELEMENT,$1,$2,$3); }
pass1/parser/grammar.y:        { $$ = mknode(ALLCONSTANTS); }
pass1/parser/grammar.y:		NODE *p = mknode(BLOCKDENOTATION, emptylist(), $2);
pass1/parser/grammar.y:		ge1 = mknode(GUARDEDELEMENT,$2,first($4));
pass1/parser/grammar.y:		ge1 = mknode(GUARDEDELEMENT,$2,
pass1/parser/grammar.y:			    mknode(BLOCKDENOTATION,emptylist(),$4));
pass1/parser/grammar.y:	    ge2 = mknode(GUARDEDELEMENT, mknode(WORDELSE), $5);
pass1/parser/grammar.y:	    $$ = mknode(GUARDEDLIST, mklist(ge1, ge2, -1));
pass1/parser/grammar.y:		ge1 = mknode(GUARDEDELEMENT,$1,first($3));
pass1/parser/grammar.y:		ge1 = mknode(GUARDEDELEMENT,$1,
pass1/parser/grammar.y:			    mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/grammar.y:	    ge2 = mknode(GUARDEDELEMENT, mknode(WORDELSE), $4);
pass1/parser/grammar.y:		$$ = mknode(GUARDEDELEMENT,$1,first($3));
pass1/parser/grammar.y:		NODE *p = mknode(GUARDEDELEMENT,$1,
pass1/parser/grammar.y:				mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/grammar.y:        { $$ = mknode(LETTERID,$1); }
pass1/parser/grammar.y:        { $$ = mknode(OPRID,$1); }
pass1/parser/grammar.y:        { $$ = mknode(QSTR,$1); }
pass1/parser/grammar.y:        { $$ = mknode(UQSTR,$1); }
pass1/parser/grammar.orig.c.y:        {  $$ = mklist( mknode(PARAMETER,NIL,$1), -1 ); }
pass1/parser/grammar.orig.c.y:	  $$ = mknode(VARSIGNATURE,$2);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(VALSIGNATURE,$2);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(TYPESIGNATURE,$11,$13,$5,$6,$7,$9);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(TYPESIGNATURE,$10,$12,$5,$6,$7,NIL);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(TYPESIGNATURE,$9,$11,$5,$6,$7,NIL);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(TYPESIGNATURE,$7,$9,$5,NIL,NIL,NIL);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(TYPESIGNATURE,$5,$7,NIL,NIL,NIL,NIL);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(TYPESIGNATURE,$2,$4,NIL,NIL,NIL,NIL);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(FUNCSIGNATURE,$3,$5,$7);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(FUNCSIGNATURE,$2,$4,$6);
pass1/parser/grammar.orig.c.y:          vl_field_sig = mknode(FUNCSIGNATURE,
pass1/parser/grammar.orig.c.y:                                mklist(mknode(PARAMETER,
pass1/parser/grammar.orig.c.y:                                              mknode(VALSIGNATURE,
pass1/parser/grammar.orig.c.y:                                                     mknode(LETTERID,-1))),
pass1/parser/grammar.orig.c.y:                                mknode(VALSIGNATURE, $5));
pass1/parser/grammar.orig.c.y:            vr_field_sig = mknode(FUNCSIGNATURE,
pass1/parser/grammar.orig.c.y:                                  mklist(mknode(PARAMETER,
pass1/parser/grammar.orig.c.y:                                                mknode(VARSIGNATURE,
pass1/parser/grammar.orig.c.y:                                                       mknode(LETTERID,-1))),
pass1/parser/grammar.orig.c.y:                                  mknode(VARSIGNATURE, $5));
pass1/parser/grammar.orig.c.y:                        result = mknode(TSCOMPONENT,$1,sig_assign);
pass1/parser/grammar.orig.c.y:                        result = mknode(TSCOMPONENT,$1,sig_less);
pass1/parser/grammar.orig.c.y:                        result = mknode(TSCOMPONENT,$1,sig_greater);
pass1/parser/grammar.orig.c.y:			result = mknode(TSCOMPONENT,$1,sig_equals);
pass1/parser/grammar.orig.c.y:			result = mknode(TSCOMPONENT,$1,sig_sconc);
pass1/parser/grammar.orig.c.y:			result = mknode(TSCOMPONENT,$1,sig_pconc);
pass1/parser/grammar.orig.c.y:                        result = mknode(TSCOMPONENT,$1,sig_New);
pass1/parser/grammar.orig.c.y:                        result = mknode(TSCOMPONENT,$1,sig_ValueOf);
pass1/parser/grammar.orig.c.y:                        result = mknode(TSCOMPONENT,$1,sig_const);
pass1/parser/grammar.orig.c.y:		$$ = mklist(mknode(DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3), -1);
pass1/parser/grammar.orig.c.y:		$$ = insrtptr = mknode(BLOCKDENOTATION,emptylist(),NIL);
pass1/parser/grammar.orig.c.y:        { $$ = mknode(WORDCAND); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(WORDCOR); }
pass1/parser/grammar.orig.c.y:	{ $$ = mknode(MODPRIMARY,$1,$2,NIL); }
pass1/parser/grammar.orig.c.y:	      $$ = p = mknode(BLOCKDENOTATION,emptylist(),$2);
pass1/parser/grammar.orig.c.y:        { $$ = mknode(GUARDEDLIST,$2); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(LOOPDENOTATION,$2); }
pass1/parser/grammar.orig.c.y:	  $$ = p = mknode(BLOCKDENOTATION,$2,$4);
pass1/parser/grammar.orig.c.y:	  $$ = p = mknode(USELIST,$2,$4);
pass1/parser/grammar.orig.c.y:	  $$ = mknode(REXTERNDEF, read_signature($3), $3);
pass1/parser/grammar.orig.c.y:	      $$ = mknode(FUNCCONSTR,$1,first($3));
pass1/parser/grammar.orig.c.y:	      $$ = mknode(FUNCCONSTR,$1,
pass1/parser/grammar.orig.c.y:			      mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/grammar.orig.c.y:	  $$ = mknode(FUNCCONSTR, $1, mknode(EXTERNDEF, $4));
pass1/parser/grammar.orig.c.y:	  $$ = mknode(FUNCSIGNATURE, $3, $5, NIL);
pass1/parser/grammar.orig.c.y:	{ $$ = mknode(FUNCSIGNATURE, $2, $4, NIL); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(WORDELSE); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(ENUMERATION,$3); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(EXTENSION,$3); }
pass1/parser/grammar.orig.c.y:	  $$ = mknode(PRODCONSTRUCTION,$2,$4); 
pass1/parser/grammar.orig.c.y:        { $$ = mknode(RECORDCONSTRUCTION,$3); }
pass1/parser/grammar.orig.c.y:          $$ = mknode(UNIONCONSTRUCTION,$2,$4);
pass1/parser/grammar.orig.c.y:	{ $$ = mknode(WITHLIST,$2,$4); }
pass1/parser/grammar.orig.c.y:	{ $$ = mknode($1,$2,$4);  }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(EXPORTELEMENT,$1,$2,$3); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(ALLCONSTANTS); }
pass1/parser/grammar.orig.c.y:		NODE *p = mknode(BLOCKDENOTATION, emptylist(), $2);
pass1/parser/grammar.orig.c.y:		ge1 = mknode(GUARDEDELEMENT,$2,first($4));
pass1/parser/grammar.orig.c.y:		ge1 = mknode(GUARDEDELEMENT,$2,
pass1/parser/grammar.orig.c.y:			    mknode(BLOCKDENOTATION,emptylist(),$4));
pass1/parser/grammar.orig.c.y:	    ge2 = mknode(GUARDEDELEMENT, mknode(WORDELSE), $5);
pass1/parser/grammar.orig.c.y:	    $$ = mknode(GUARDEDLIST, mklist(ge1, ge2, -1));
pass1/parser/grammar.orig.c.y:		ge1 = mknode(GUARDEDELEMENT,$1,first($3));
pass1/parser/grammar.orig.c.y:		ge1 = mknode(GUARDEDELEMENT,$1,
pass1/parser/grammar.orig.c.y:			    mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/grammar.orig.c.y:	    ge2 = mknode(GUARDEDELEMENT, mknode(WORDELSE), $4);
pass1/parser/grammar.orig.c.y:		$$ = mknode(GUARDEDELEMENT,$1,first($3));
pass1/parser/grammar.orig.c.y:		NODE *p = mknode(GUARDEDELEMENT,$1,
pass1/parser/grammar.orig.c.y:				mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/grammar.orig.c.y:        { $$ = mknode(LETTERID,$1); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(OPRID,$1); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(QSTR,$1); }
pass1/parser/grammar.orig.c.y:        { $$ = mknode(UQSTR,$1); }
pass1/parser/grammar.1st.convert.y:    {  $$ := mklist([ mknode([PARAMETER,nil,$1]), -1 ]) }
pass1/parser/grammar.1st.convert.y:$$ := mknode([VARSIGNATURE,$2])
pass1/parser/grammar.1st.convert.y:$$ := mknode([VALSIGNATURE,$2])
pass1/parser/grammar.1st.convert.y:$$ := mknode([TYPESIGNATURE,$11,$13,$5,$6,$7,$9])
pass1/parser/grammar.1st.convert.y:$$ := mknode([TYPESIGNATURE,$10,$12,$5,$6,$7,nil])
pass1/parser/grammar.1st.convert.y:$$ := mknode([TYPESIGNATURE,$9,$11,$5,$6,$7,nil])
pass1/parser/grammar.1st.convert.y:$$ := mknode([TYPESIGNATURE,$7,$9,$5,nil,nil,nil])
pass1/parser/grammar.1st.convert.y:$$ := mknode([TYPESIGNATURE,$5,$7,nil,nil,nil,nil])
pass1/parser/grammar.1st.convert.y:$$ := mknode([TYPESIGNATURE,$2,$4,nil,nil,nil,nil])
pass1/parser/grammar.1st.convert.y:$$ := mknode([FUNCSIGNATURE,$3,$5,$7])
pass1/parser/grammar.1st.convert.y:$$ := mknode([FUNCSIGNATURE,$2,$4,$6])
pass1/parser/grammar.1st.convert.y:    vl_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.1st.convert.y:			    mklist([mknode([PARAMETER,
pass1/parser/grammar.1st.convert.y:					    mknode([VALSIGNATURE,
pass1/parser/grammar.1st.convert.y:						    mknode([LETTERID,-1])])]),
pass1/parser/grammar.1st.convert.y:			    mknode([VALSIGNATURE, $5])])
pass1/parser/grammar.1st.convert.y:vr_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.1st.convert.y:			mklist([mknode([PARAMETER,
pass1/parser/grammar.1st.convert.y:					mknode([VARSIGNATURE,
pass1/parser/grammar.1st.convert.y:						mknode([LETTERID,-1])])]),
pass1/parser/grammar.1st.convert.y:			mknode([VARSIGNATURE, $5])])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_assign])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_less])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_greater])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_equals])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_sconc])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_pconc])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_New])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_ValueOf])
pass1/parser/grammar.1st.convert.y:    result := mknode([TSCOMPONENT,$1,sig_const])
pass1/parser/grammar.1st.convert.y:    $$ := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3]), -1])
pass1/parser/grammar.1st.convert.y:$$ := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
pass1/parser/grammar.1st.convert.y:{ $$ := mknode([WORDCAND]) }
pass1/parser/grammar.1st.convert.y:{ $$ := mknode([WORDCOR]) }
pass1/parser/grammar.1st.convert.y:{ $$ := mknode([MODPRIMARY,$1,$2,nil]) }
pass1/parser/grammar.1st.convert.y:$$ := p := mknode([BLOCKDENOTATION,emptylist(),$2])
pass1/parser/grammar.1st.convert.y:    { $$ := mknode([GUARDEDLIST,$2]) }
pass1/parser/grammar.1st.convert.y:    { $$ := mknode([LOOPDENOTATION,$2]) }
pass1/parser/grammar.1st.convert.y:$$ := p := mknode([BLOCKDENOTATION,$2,$4])
pass1/parser/grammar.1st.convert.y:$$ := p := mknode([USELIST,$2,$4])
pass1/parser/grammar.1st.convert.y:$$ := mknode([REXTERNDEF, read_signature($3), $3])
pass1/parser/grammar.1st.convert.y:$$ := mknode([FUNCCONSTR,$1,first($3)])
pass1/parser/grammar.1st.convert.y:$$ := mknode([FUNCCONSTR,$1,
pass1/parser/grammar.1st.convert.y:	      mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.1st.convert.y:	  $$ := mknode([FUNCCONSTR, $1, mknode([EXTERNDEF, $4])])
pass1/parser/grammar.1st.convert.y:	  $$ := mknode([FUNCSIGNATURE, $3, $5, nil])
pass1/parser/grammar.1st.convert.y:	{ $$ := mknode([FUNCSIGNATURE, $2, $4, nil]) }
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([WORDELSE]) }
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([ENUMERATION,$3]) }
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([EXTENSION,$3]) }
pass1/parser/grammar.1st.convert.y:	  $$ := mknode([PRODCONSTRUCTION,$2,$4]) 
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([RECORDCONSTRUCTION,$3]) }
pass1/parser/grammar.1st.convert.y:          $$ := mknode([UNIONCONSTRUCTION,$2,$4])
pass1/parser/grammar.1st.convert.y:	{ $$ := mknode([WITHLIST,$2,$4]) }
pass1/parser/grammar.1st.convert.y:	{ $$ := mknode([$1,$2,$4])  }
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([EXPORTELEMENT,$1,$2,$3]) }
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([ALLCONSTANTS]) }
pass1/parser/grammar.1st.convert.y:		p := mknode([BLOCKDENOTATION, emptylist(), $2])
pass1/parser/grammar.1st.convert.y:		ge1 := mknode([GUARDEDELEMENT,$2,first($4)])
pass1/parser/grammar.1st.convert.y:		ge1 := mknode([GUARDEDELEMENT,$2,
pass1/parser/grammar.1st.convert.y:			    mknode([BLOCKDENOTATION,emptylist(),$4])])
pass1/parser/grammar.1st.convert.y:    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), $5])
pass1/parser/grammar.1st.convert.y:$$ := mknode([GUARDEDLIST, mklist([ge1, ge2, -1])])
pass1/parser/grammar.1st.convert.y:ge1 := mknode([GUARDEDELEMENT,$1,first($3)])
pass1/parser/grammar.1st.convert.y:ge1 := mknode([GUARDEDELEMENT,$1,
pass1/parser/grammar.1st.convert.y:	       mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.1st.convert.y:	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), $4])
pass1/parser/grammar.1st.convert.y:$$ := mknode([GUARDEDELEMENT,$1,first($3)])
pass1/parser/grammar.1st.convert.y:p := mknode([GUARDEDELEMENT,$1,
pass1/parser/grammar.1st.convert.y:		   mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([LETTERID,$1]) }
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([OPRID,$1]) }
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([QSTR,$1]) }
pass1/parser/grammar.1st.convert.y:        { $$ := mknode([UQSTR,$1]) }
pass1/parser/#initids.icn#:        id_Boolean := mknode([LETTERID, indx_Boolean])
pass1/parser/#initids.icn#:        id_Void := mknode([LETTERID, indx_Void])
pass1/parser/#initids.icn#:	id_Integer := mknode([LETTERID, indx_Integer])
pass1/parser/#initids.icn#:	id_put := mknode([LETTERID, indx_put])
pass1/parser/#initids.icn#:	id_ValueOf := mknode([LETTERID, indx_ValueOf])
pass1/parser/#initids.icn#:	id_New := mknode([LETTERID, indx_New])
pass1/parser/#initids.icn#:	id_size := mknode([LETTERID, indx_size])
pass1/parser/#initids.icn#:	id_Null := mknode([LETTERID, indx_Null])
pass1/parser/#initids.icn#:	id_times := mknode([LETTERID, indx_times])
pass1/parser/#initids.icn#:	id_plus := mknode([LETTERID, indx_plus])
pass1/parser/#initids.icn#:        val_Boolean := lock( mknode([VALSIGNATURE,
pass1/parser/#initids.icn#:	val_Integer := lock( mknode([VALSIGNATURE,
pass1/parser/#initids.icn#:        val_Void    := lock( mknode([VALSIGNATURE,
pass1/parser/#initids.icn#:        var_Void    := lock( mknode([VARSIGNATURE,
pass1/parser/#initids.icn#:        val_param := lock( mknode([PARAMETER,
pass1/parser/#initids.icn#:                                 mknode([VALSIGNATURE,
pass1/parser/#initids.icn#:                                        mknode([LETTERID])
pass1/parser/#initids.icn#:        var_param := lock( mknode([PARAMETER,
pass1/parser/#initids.icn#:                                 mknode([VARSIGNATURE,
pass1/parser/#initids.icn#:                                        mknode([LETTERID])
pass1/parser/#initids.icn#:	sig_assign := lock( mknode([FUNCSIGNATURE, nil, as_params,
pass1/parser/#initids.icn#:	    lock( mknode([FUNCSIGNATURE, nil, two_params,
pass1/parser/#initids.icn#:	    lock( mknode([FUNCSIGNATURE, nil, two_params,val_Boolean]) )
pass1/parser/#initids.icn#:	sig_New := lock( mknode([FUNCSIGNATURE, nil, emptylist(),
pass1/parser/#initids.icn#:	sig_const := lock( mknode([FUNCSIGNATURE, nil, emptylist(),
pass1/parser/#initids.icn#:	sig_ValueOf := lock( mknode([FUNCSIGNATURE, nil,
pass1/parser/#initids.icn#:	sig_Signature := lock(mknode([SIGNATURESIG]))
pass1/parser/#initids.icn#:        sel_true := mknode([LETTERID,indx_true])
pass1/parser/#initids.icn#:        sel_true := mknode([APPLICATION, sel_true, emptylist()])
pass1/parser/#initids.icn#:        sel_false := mknode([LETTERID,indx_false])
pass1/parser/#initids.icn#:        sel_false := mknode([APPLICATION, sel_false, emptylist()])
pass1/parser/#initids.icn#:	appl_Null := mknode([APPLICATION, id_Null, emptylist()])
pass1/parser/grammar.base.icn:    {  yyval := mklist([ mknode([PARAMETER,nil,valstk[1]])]) }
pass1/parser/grammar.base.icn:yyval := mknode([VARSIGNATURE,valstk[1]])
pass1/parser/grammar.base.icn:yyval := mknode([VALSIGNATURE,valstk[1]])
pass1/parser/grammar.base.icn:yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[10],valstk[9],valstk[8],valstk[6]])
pass1/parser/grammar.base.icn:yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[9],valstk[8],valstk[7],nil])
pass1/parser/grammar.base.icn:yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[8],valstk[7],valstk[6],nil])
pass1/parser/grammar.base.icn:yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[6],nil,nil,nil])
pass1/parser/grammar.base.icn:yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
pass1/parser/grammar.base.icn:yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
pass1/parser/grammar.base.icn:yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
pass1/parser/grammar.base.icn:yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
pass1/parser/grammar.base.icn:    vl_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.base.icn:			    mklist([mknode([PARAMETER,
pass1/parser/grammar.base.icn:					    mknode([VALSIGNATURE,
pass1/parser/grammar.base.icn:						    mknode([LETTERID])])])
pass1/parser/grammar.base.icn:			    mknode([VALSIGNATURE, valstk[1]])])
pass1/parser/grammar.base.icn:vr_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.base.icn:			mklist([mknode([PARAMETER,
pass1/parser/grammar.base.icn:					mknode([VARSIGNATURE,
pass1/parser/grammar.base.icn:						mknode([LETTERID])])])
pass1/parser/grammar.base.icn:			mknode([VARSIGNATURE, valstk[1]])])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_assign])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_less])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_greater])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_equals])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_sconc])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_pconc])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_New])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_ValueOf])
pass1/parser/grammar.base.icn:    result := mknode([TSCOMPONENT,valstk[1],sig_const])
pass1/parser/grammar.base.icn:    yyval := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3])])
pass1/parser/grammar.base.icn:yyval := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
pass1/parser/grammar.base.icn: yyval := mknode([WORDCAND]) 
pass1/parser/grammar.base.icn: yyval := mknode([WORDCOR]) 
pass1/parser/grammar.base.icn: yyval := mknode([MODPRIMARY,valstk[2],valstk[1],nil]) 
pass1/parser/grammar.base.icn:yyval := p := mknode([BLOCKDENOTATION,emptylist(),valstk[2]])
pass1/parser/grammar.base.icn:    { yyval := mknode([GUARDEDLIST,valstk[2]]) }
pass1/parser/grammar.base.icn:    { yyval := mknode([LOOPDENOTATION,valstk[2]])} 
pass1/parser/grammar.base.icn:yyval := p := mknode([BLOCKDENOTATION,valstk[4],valstk[2]])
pass1/parser/grammar.base.icn:yyval := p := mknode([USELIST,valstk[4],valstk[2]])
pass1/parser/grammar.base.icn:yyval := mknode([REXTERNDEF, read_signature(valstk[2]), valstk[2]])
pass1/parser/grammar.base.icn:yyval := mknode([FUNCCONSTR,valstk[4],first(valstk[2])])
pass1/parser/grammar.base.icn:yyval := mknode([FUNCCONSTR,valstk[4],
pass1/parser/grammar.base.icn:	      mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.base.icn:	  yyval := mknode([FUNCCONSTR, valstk[5], mknode([EXTERNDEF, valstk[2]])])
pass1/parser/grammar.base.icn:	  yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])
pass1/parser/grammar.base.icn:	{ yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])} 
pass1/parser/grammar.base.icn:        { yyval := mknode([WORDELSE]) }
pass1/parser/grammar.base.icn:        { yyval := mknode([ENUMERATION,valstk[2]]) }
pass1/parser/grammar.base.icn:        { yyval := mknode([EXTENSION,valstk[2]]) }
pass1/parser/grammar.base.icn:	    yyval := mknode([PRODCONSTRUCTION,valstk[4],valstk[2]]) 
pass1/parser/grammar.base.icn:        { yyval := mknode([RECORDCONSTRUCTION,valstk[2]]) }
pass1/parser/grammar.base.icn:          yyval := mknode([UNIONCONSTRUCTION,valstk[4],valstk[2]])
pass1/parser/grammar.base.icn:	{ yyval := mknode([WITHLIST,valstk[4],valstk[2]]) }
pass1/parser/grammar.base.icn:	{ yyval := mknode([valstk[5],valstk[4],valstk[2]]) } 
pass1/parser/grammar.base.icn:        { yyval := mknode([EXPORTELEMENT,valstk[3],valstk[2],valstk[1]]) }
pass1/parser/grammar.base.icn:        { yyval := mknode([ALLCONSTANTS]) }
pass1/parser/grammar.base.icn:		p := mknode([BLOCKDENOTATION, emptylist(), valstk[1]])
pass1/parser/grammar.base.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
pass1/parser/grammar.base.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],
pass1/parser/grammar.base.icn:			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.base.icn:    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
pass1/parser/grammar.base.icn:yyval := mknode([GUARDEDLIST, mklist([ge1, ge2])])
pass1/parser/grammar.base.icn:ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
pass1/parser/grammar.base.icn:ge1 := mknode([GUARDEDELEMENT,valstk[4],
pass1/parser/grammar.base.icn:	       mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.base.icn:	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
pass1/parser/grammar.base.icn:yyval := mknode([GUARDEDELEMENT,valstk[3],first(valstk[1])])
pass1/parser/grammar.base.icn:p := mknode([GUARDEDELEMENT,valstk[3],
pass1/parser/grammar.base.icn:		   mknode([BLOCKDENOTATION,emptylist(),valstk[1]])])
pass1/parser/grammar.base.icn:        { yyval := mknode([LETTERID,valstk[1]]) }
pass1/parser/grammar.base.icn:        { yyval := mknode([OPRID,valstk[1]]) }
pass1/parser/grammar.base.icn:        { yyval := mknode([QSTR,valstk[1]]) }
pass1/parser/grammar.base.icn:        { yyval := mknode([UQSTR,valstk[1]]) }
pass1/parser/#grammar.y#:        {  $$ = mklist( mknode(PARAMETER,NIL,$1), -1 ); }
pass1/parser/#grammar.y#:	  $$ = mknode(VARSIGNATURE,$2);
pass1/parser/#grammar.y#:	  $$ = mknode(VALSIGNATURE,$2);
pass1/parser/#grammar.y#:	  $$ = mknode(TYPESIGNATURE,$11,$13,$5,$6,$7,$9);
pass1/parser/#grammar.y#:	  $$ = mknode(TYPESIGNATURE,$10,$12,$5,$6,$7,NIL);
pass1/parser/#grammar.y#:	  $$ = mknode(TYPESIGNATURE,$9,$11,$5,$6,$7,NIL);
pass1/parser/#grammar.y#:	  $$ = mknode(TYPESIGNATURE,$7,$9,$5,NIL,NIL,NIL);
pass1/parser/#grammar.y#:	  $$ = mknode(TYPESIGNATURE,$5,$7,NIL,NIL,NIL,NIL);
pass1/parser/#grammar.y#:	  $$ = mknode(TYPESIGNATURE,$2,$4,NIL,NIL,NIL,NIL);
pass1/parser/#grammar.y#:	  $$ = mknode(FUNCSIGNATURE,$3,$5,$7);
pass1/parser/#grammar.y#:	  $$ = mknode(FUNCSIGNATURE,$2,$4,$6);
pass1/parser/#grammar.y#:          vl_field_sig = mknode(FUNCSIGNATURE,
pass1/parser/#grammar.y#:                                mklist(mknode(PARAMETER,
pass1/parser/#grammar.y#:                                              mknode(VALSIGNATURE,
pass1/parser/#grammar.y#:                                                     mknode(LETTERID,-1))),
pass1/parser/#grammar.y#:                                mknode(VALSIGNATURE, $5));
pass1/parser/#grammar.y#:            vr_field_sig = mknode(FUNCSIGNATURE,
pass1/parser/#grammar.y#:                                  mklist(mknode(PARAMETER,
pass1/parser/#grammar.y#:                                                mknode(VARSIGNATURE,
pass1/parser/#grammar.y#:                                                       mknode(LETTERID,-1))),
pass1/parser/#grammar.y#:                                  mknode(VARSIGNATURE, $5));
pass1/parser/#grammar.y#:                        result = mknode(TSCOMPONENT,$1,sig_assign);
pass1/parser/#grammar.y#:                        result = mknode(TSCOMPONENT,$1,sig_less);
pass1/parser/#grammar.y#:                        result = mknode(TSCOMPONENT,$1,sig_greater);
pass1/parser/#grammar.y#:			result = mknode(TSCOMPONENT,$1,sig_equals);
pass1/parser/#grammar.y#:			result = mknode(TSCOMPONENT,$1,sig_sconc);
pass1/parser/#grammar.y#:			result = mknode(TSCOMPONENT,$1,sig_pconc);
pass1/parser/#grammar.y#:                        result = mknode(TSCOMPONENT,$1,sig_New);
pass1/parser/#grammar.y#:                        result = mknode(TSCOMPONENT,$1,sig_ValueOf);
pass1/parser/#grammar.y#:                        result = mknode(TSCOMPONENT,$1,sig_const);
pass1/parser/#grammar.y#:		$$ = mklist(mknode(DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3), -1);
pass1/parser/#grammar.y#:		$$ = insrtptr = mknode(BLOCKDENOTATION,emptylist(),NIL);
pass1/parser/#grammar.y#:        { $$ = mknode(WORDCAND); }
pass1/parser/#grammar.y#:        { $$ = mknode(WORDCOR); }
pass1/parser/#grammar.y#:	{ $$ = mknode(MODPRIMARY,$1,$2,NIL); }
pass1/parser/#grammar.y#:	      $$ = p = mknode(BLOCKDENOTATION,emptylist(),$2);
pass1/parser/#grammar.y#:        { $$ = mknode(GUARDEDLIST,$2); }
pass1/parser/#grammar.y#:        { $$ = mknode(LOOPDENOTATION,$2); }
pass1/parser/#grammar.y#:	  $$ = p = mknode(BLOCKDENOTATION,$2,$4);
pass1/parser/#grammar.y#:	  $$ = p = mknode(USELIST,$2,$4);
pass1/parser/#grammar.y#:	  $$ = mknode(REXTERNDEF, read_signature($3), $3);
pass1/parser/#grammar.y#:	      $$ = mknode(FUNCCONSTR,$1,first($3));
pass1/parser/#grammar.y#:	      $$ = mknode(FUNCCONSTR,$1,
pass1/parser/#grammar.y#:			      mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/#grammar.y#:	  $$ = mknode(FUNCCONSTR, $1, mknode(EXTERNDEF, $4));
pass1/parser/#grammar.y#:	  $$ = mknode(FUNCSIGNATURE, $3, $5, NIL);
pass1/parser/#grammar.y#:	{ $$ = mknode(FUNCSIGNATURE, $2, $4, NIL); }
pass1/parser/#grammar.y#:        { $$ = mknode(WORDELSE); }
pass1/parser/#grammar.y#:        { $$ = mknode(ENUMERATION,$3); }
pass1/parser/#grammar.y#:        { $$ = mknode(EXTENSION,$3); }
pass1/parser/#grammar.y#:	  $$ = mknode(PRODCONSTRUCTION,$2,$4); 
pass1/parser/#grammar.y#:        { $$ = mknode(RECORDCONSTRUCTION,$3); }
pass1/parser/#grammar.y#:          $$ = mknode(UNIONCONSTRUCTION,$2,$4);
pass1/parser/#grammar.y#:	{ $$ = mknode(WITHLIST,$2,$4); }
pass1/parser/#grammar.y#:	{ $$ = mknode($1,$2,$4);  }
pass1/parser/#grammar.y#:        { $$ = mknode(EXPORTELEMENT,$1,$2,$3); }
pass1/parser/#grammar.y#:        { $$ = mknode(ALLCONSTANTS); }
pass1/parser/#grammar.y#:		NODE *p = mknode(BLOCKDENOTATION, emptylist(), $2);
pass1/parser/#grammar.y#:		ge1 = mknode(GUARDEDELEMENT,$2,first($4));
pass1/parser/#grammar.y#:		ge1 = mknode(GUARDEDELEMENT,$2,
pass1/parser/#grammar.y#:			    mknode(BLOCKDENOTATION,emptylist(),$4));
pass1/parser/#grammar.y#:	    ge2 = mknode(GUARDEDELEMENT, mknode(WORDELSE), $5);
pass1/parser/#grammar.y#:	    $$ = mknode(GUARDEDLIST, mklist(ge1, ge2, -1));
pass1/parser/#grammar.y#:		ge1 = mknode(GUARDEDELEMENT,$1,first($3));
pass1/parser/#grammar.y#:		ge1 = mknode(GUARDEDELEMENT,$1,
pass1/parser/#grammar.y#:			    mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/#grammar.y#:	    ge2 = mknode(GUARDEDELEMENT, mknode(WORDELSE), $4);
pass1/parser/#grammar.y#:		$$ = mknode(GUARDEDELEMENT,$1,first($3));
pass1/parser/#grammar.y#:		NODE *p = mknode(GUARDEDELEMENT,$1,
pass1/parser/#grammar.y#:				mknode(BLOCKDENOTATION,emptylist(),$3));
pass1/parser/#grammar.y#:        { $$ = mknode(LETTERID,$1); }
pass1/parser/#grammar.y#:        { $$ = mknode(OPRID,$1); }
pass1/parser/#grammar.y#:        { $$ = mknode(QSTR,$1); }
pass1/parser/#grammar.y#:        { $$ = mknode(UQSTR,$1); }
pass1/parser/initids.icn:        id_Boolean := mknode([LETTERID, indx_Boolean])
pass1/parser/initids.icn:        id_Void := mknode([LETTERID, indx_Void])
pass1/parser/initids.icn:	id_Integer := mknode([LETTERID, indx_Integer])
pass1/parser/initids.icn:	id_put := mknode([LETTERID, indx_put])
pass1/parser/initids.icn:	id_ValueOf := mknode([LETTERID, indx_ValueOf])
pass1/parser/initids.icn:	id_New := mknode([LETTERID, indx_New])
pass1/parser/initids.icn:	id_size := mknode([LETTERID, indx_size])
pass1/parser/initids.icn:	id_Null := mknode([LETTERID, indx_Null])
pass1/parser/initids.icn:	id_times := mknode([LETTERID, indx_times])
pass1/parser/initids.icn:	id_plus := mknode([LETTERID, indx_plus])
pass1/parser/initids.icn:        val_Boolean := lock( mknode([VALSIGNATURE,
pass1/parser/initids.icn:	val_Integer := lock( mknode([VALSIGNATURE,
pass1/parser/initids.icn:        val_Void    := lock( mknode([VALSIGNATURE,
pass1/parser/initids.icn:        var_Void    := lock( mknode([VARSIGNATURE,
pass1/parser/initids.icn:        val_param := lock( mknode([PARAMETER,
pass1/parser/initids.icn:                                 mknode([VALSIGNATURE,
pass1/parser/initids.icn:                                        mknode([LETTERID])
pass1/parser/initids.icn:        var_param := lock( mknode([PARAMETER,
pass1/parser/initids.icn:                                 mknode([VARSIGNATURE,
pass1/parser/initids.icn:                                        mknode([LETTERID])
pass1/parser/initids.icn:	sig_assign := lock( mknode([FUNCSIGNATURE, nil, as_params,
pass1/parser/initids.icn:	    lock( mknode([FUNCSIGNATURE, nil, two_params,
pass1/parser/initids.icn:	    lock( mknode([FUNCSIGNATURE, nil, two_params,val_Boolean]) )
pass1/parser/initids.icn:	sig_New := lock( mknode([FUNCSIGNATURE, nil, emptylist(),
pass1/parser/initids.icn:	sig_const := lock( mknode([FUNCSIGNATURE, nil, emptylist(),
pass1/parser/initids.icn:	sig_ValueOf := lock( mknode([FUNCSIGNATURE, nil,
pass1/parser/initids.icn:	sig_Signature := lock(mknode([SIGNATURESIG]))
pass1/parser/initids.icn:        sel_true := mknode([LETTERID,indx_true])
pass1/parser/initids.icn:        sel_true := mknode([APPLICATION, sel_true, emptylist()])
pass1/parser/initids.icn:        sel_false := mknode([LETTERID,indx_false])
pass1/parser/initids.icn:        sel_false := mknode([APPLICATION, sel_false, emptylist()])
pass1/parser/initids.icn:	appl_Null := mknode([APPLICATION, id_Null, emptylist()])
pass1/parser/grammar.indent.y:        {  $$ := mklist([ mknode([PARAMETER,nil,$1]) ]) }
pass1/parser/grammar.indent.y:	  $$ := mknode([VARSIGNATURE,$2])
pass1/parser/grammar.indent.y:	  $$ := mknode([VALSIGNATURE,$2])
pass1/parser/grammar.indent.y:	  $$ := mknode([TYPESIGNATURE,$11,$13,$5,$6,$7,$9])
pass1/parser/grammar.indent.y:	  $$ := mknode([TYPESIGNATURE,$10,$12,$5,$6,$7,nil])
pass1/parser/grammar.indent.y:	  $$ := mknode([TYPESIGNATURE,$9,$11,$5,$6,$7,nil])
pass1/parser/grammar.indent.y:	  $$ := mknode([TYPESIGNATURE,$7,$9,$5,nil,nil,nil])
pass1/parser/grammar.indent.y:	  $$ := mknode([TYPESIGNATURE,$5,$7,nil,nil,nil,nil])
pass1/parser/grammar.indent.y:	  $$ := mknode([TYPESIGNATURE,$2,$4,nil,nil,nil,nil])
pass1/parser/grammar.indent.y:	  $$ := mknode([FUNCSIGNATURE,$3,$5,$7])
pass1/parser/grammar.indent.y:	  $$ := mknode([FUNCSIGNATURE,$2,$4,$6])
pass1/parser/grammar.indent.y:          vl_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.indent.y:                                mklist([mknode([PARAMETER,
pass1/parser/grammar.indent.y:                                              mknode([VALSIGNATURE,
pass1/parser/grammar.indent.y:                                                     mknode([LETTERID])])])
pass1/parser/grammar.indent.y:                                mknode([VALSIGNATURE, $5])])
pass1/parser/grammar.indent.y:            vr_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.indent.y:                                  mklist([mknode([PARAMETER,
pass1/parser/grammar.indent.y:                                                mknode([VARSIGNATURE,
pass1/parser/grammar.indent.y:                                                       mknode([LETTERID])])])
pass1/parser/grammar.indent.y:                                  mknode([VARSIGNATURE, $5])])
pass1/parser/grammar.indent.y:                        result := mknode([TSCOMPONENT,$1,sig_assign])
pass1/parser/grammar.indent.y:                        result := mknode([TSCOMPONENT,$1,sig_less])
pass1/parser/grammar.indent.y:                        result := mknode([TSCOMPONENT,$1,sig_greater])
pass1/parser/grammar.indent.y:			result := mknode([TSCOMPONENT,$1,sig_equals])
pass1/parser/grammar.indent.y:			result := mknode([TSCOMPONENT,$1,sig_sconc])
pass1/parser/grammar.indent.y:			result := mknode([TSCOMPONENT,$1,sig_pconc])
pass1/parser/grammar.indent.y:                        result := mknode([TSCOMPONENT,$1,sig_New])
pass1/parser/grammar.indent.y:                        result := mknode([TSCOMPONENT,$1,sig_ValueOf])
pass1/parser/grammar.indent.y:                        result := mknode([TSCOMPONENT,$1,sig_const])
pass1/parser/grammar.indent.y:		$$ := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3])])
pass1/parser/grammar.indent.y:		$$ := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
pass1/parser/grammar.indent.y:        { $$ := mknode([WORDCAND]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([WORDCOR]) }
pass1/parser/grammar.indent.y:	{ $$ := mknode([MODPRIMARY,$1,$2,nil]) }
pass1/parser/grammar.indent.y:	      $$ := p := mknode([BLOCKDENOTATION,emptylist(),$2])
pass1/parser/grammar.indent.y:        { $$ := mknode([GUARDEDLIST,$2]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([LOOPDENOTATION,$2]) }
pass1/parser/grammar.indent.y:	  $$ := p := mknode([BLOCKDENOTATION,$2,$4])
pass1/parser/grammar.indent.y:	  $$ := p := mknode([USELIST,$2,$4])
pass1/parser/grammar.indent.y:	  $$ := mknode([REXTERNDEF, read_signature($3), $3])
pass1/parser/grammar.indent.y:	      $$ := mknode([FUNCCONSTR,$1,first($3)])
pass1/parser/grammar.indent.y:	      $$ := mknode([FUNCCONSTR,$1,
pass1/parser/grammar.indent.y:			      mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.indent.y:	  $$ := mknode([FUNCCONSTR, $1, mknode([EXTERNDEF, $4])])
pass1/parser/grammar.indent.y:	  $$ := mknode([FUNCSIGNATURE, $3, $5, nil])
pass1/parser/grammar.indent.y:	{ $$ := mknode([FUNCSIGNATURE, $2, $4, nil]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([WORDELSE]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([ENUMERATION,$3]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([EXTENSION,$3]) }
pass1/parser/grammar.indent.y:	  $$ := mknode([PRODCONSTRUCTION,$2,$4]) 
pass1/parser/grammar.indent.y:        { $$ := mknode([RECORDCONSTRUCTION,$3]) }
pass1/parser/grammar.indent.y:          $$ := mknode([UNIONCONSTRUCTION,$2,$4])
pass1/parser/grammar.indent.y:	{ $$ := mknode([WITHLIST,$2,$4]) }
pass1/parser/grammar.indent.y:	{ $$ := mknode([$1,$2,$4])  }
pass1/parser/grammar.indent.y:        { $$ := mknode([EXPORTELEMENT,$1,$2,$3]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([ALLCONSTANTS]) }
pass1/parser/grammar.indent.y:		p := mknode([BLOCKDENOTATION, emptylist(), $2])
pass1/parser/grammar.indent.y:		ge1 := mknode([GUARDEDELEMENT,$2,first($4)])
pass1/parser/grammar.indent.y:		ge1 := mknode([GUARDEDELEMENT,$2,
pass1/parser/grammar.indent.y:			    mknode([BLOCKDENOTATION,emptylist(),$4])])
pass1/parser/grammar.indent.y:		    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), $5])
pass1/parser/grammar.indent.y:	    $$ := mknode([GUARDEDLIST, mklist([ge1, ge2])])
pass1/parser/grammar.indent.y:		ge1 := mknode([GUARDEDELEMENT,$1,first($3)])
pass1/parser/grammar.indent.y:		ge1 := mknode([GUARDEDELEMENT,$1,
pass1/parser/grammar.indent.y:			    mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.indent.y:	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), $4])
pass1/parser/grammar.indent.y:		$$ := mknode([GUARDEDELEMENT,$1,first($3)])
pass1/parser/grammar.indent.y:		p := mknode([GUARDEDELEMENT,$1,
pass1/parser/grammar.indent.y:				mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.indent.y:        { $$ := mknode([LETTERID,$1]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([OPRID,$1]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([QSTR,$1]) }
pass1/parser/grammar.indent.y:        { $$ := mknode([UQSTR,$1]) }
pass1/parser/grammar.edit.y:        {  $$ := mklist([ mknode([PARAMETER,nil,$1]) ]) }
pass1/parser/grammar.edit.y:	  $$ := mknode([VARSIGNATURE,$2])
pass1/parser/grammar.edit.y:	  $$ := mknode([VALSIGNATURE,$2])
pass1/parser/grammar.edit.y:	  $$ := mknode([TYPESIGNATURE,$11,$13,$5,$6,$7,$9])
pass1/parser/grammar.edit.y:	  $$ := mknode([TYPESIGNATURE,$10,$12,$5,$6,$7,nil])
pass1/parser/grammar.edit.y:	  $$ := mknode([TYPESIGNATURE,$9,$11,$5,$6,$7,nil])
pass1/parser/grammar.edit.y:	  $$ := mknode([TYPESIGNATURE,$7,$9,$5,nil,nil,nil])
pass1/parser/grammar.edit.y:	  $$ := mknode([TYPESIGNATURE,$5,$7,nil,nil,nil,nil])
pass1/parser/grammar.edit.y:	  $$ := mknode([TYPESIGNATURE,$2,$4,nil,nil,nil,nil])
pass1/parser/grammar.edit.y:	  $$ := mknode([FUNCSIGNATURE,$3,$5,$7])
pass1/parser/grammar.edit.y:	  $$ := mknode([FUNCSIGNATURE,$2,$4,$6])
pass1/parser/grammar.edit.y:          vl_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.edit.y:                                mklist([mknode([PARAMETER,
pass1/parser/grammar.edit.y:                                              mknode([VALSIGNATURE,
pass1/parser/grammar.edit.y:                                                     mknode([LETTERID])])])
pass1/parser/grammar.edit.y:                                mknode([VALSIGNATURE, $5])])
pass1/parser/grammar.edit.y:            vr_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.edit.y:                                  mklist([mknode([PARAMETER,
pass1/parser/grammar.edit.y:                                                mknode([VARSIGNATURE,
pass1/parser/grammar.edit.y:                                                       mknode([LETTERID])])])
pass1/parser/grammar.edit.y:                                  mknode([VARSIGNATURE, $5])])
pass1/parser/grammar.edit.y:                        result := mknode([TSCOMPONENT,$1,sig_assign])
pass1/parser/grammar.edit.y:                        result := mknode([TSCOMPONENT,$1,sig_less])
pass1/parser/grammar.edit.y:                        result := mknode([TSCOMPONENT,$1,sig_greater])
pass1/parser/grammar.edit.y:			result := mknode([TSCOMPONENT,$1,sig_equals])
pass1/parser/grammar.edit.y:			result := mknode([TSCOMPONENT,$1,sig_sconc])
pass1/parser/grammar.edit.y:			result := mknode([TSCOMPONENT,$1,sig_pconc])
pass1/parser/grammar.edit.y:                        result := mknode([TSCOMPONENT,$1,sig_New])
pass1/parser/grammar.edit.y:                        result := mknode([TSCOMPONENT,$1,sig_ValueOf])
pass1/parser/grammar.edit.y:                        result := mknode([TSCOMPONENT,$1,sig_const])
pass1/parser/grammar.edit.y:		$$ := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3])])
pass1/parser/grammar.edit.y:		$$ := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
pass1/parser/grammar.edit.y:        { $$ := mknode([WORDCAND]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([WORDCOR]) }
pass1/parser/grammar.edit.y:	{ $$ := mknode([MODPRIMARY,$1,$2,nil]) }
pass1/parser/grammar.edit.y:	      $$ := p := mknode([BLOCKDENOTATION,emptylist(),$2])
pass1/parser/grammar.edit.y:        { $$ := mknode([GUARDEDLIST,$2]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([LOOPDENOTATION,$2]) }
pass1/parser/grammar.edit.y:	  $$ := p := mknode([BLOCKDENOTATION,$2,$4])
pass1/parser/grammar.edit.y:	  $$ := p := mknode([USELIST,$2,$4])
pass1/parser/grammar.edit.y:	  $$ := mknode([REXTERNDEF, read_signature($3), $3])
pass1/parser/grammar.edit.y:	      $$ := mknode([FUNCCONSTR,$1,first($3)])
pass1/parser/grammar.edit.y:	      $$ := mknode([FUNCCONSTR,$1,
pass1/parser/grammar.edit.y:			      mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.edit.y:	  $$ := mknode([FUNCCONSTR, $1, mknode([EXTERNDEF, $4])])
pass1/parser/grammar.edit.y:	  $$ := mknode([FUNCSIGNATURE, $3, $5, nil])
pass1/parser/grammar.edit.y:	{ $$ := mknode([FUNCSIGNATURE, $2, $4, nil]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([WORDELSE]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([ENUMERATION,$3]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([EXTENSION,$3]) }
pass1/parser/grammar.edit.y:	  $$ := mknode([PRODCONSTRUCTION,$2,$4]) 
pass1/parser/grammar.edit.y:        { $$ := mknode([RECORDCONSTRUCTION,$3]) }
pass1/parser/grammar.edit.y:          $$ := mknode([UNIONCONSTRUCTION,$2,$4])
pass1/parser/grammar.edit.y:	{ $$ := mknode([WITHLIST,$2,$4]) }
pass1/parser/grammar.edit.y:	{ $$ := mknode([$1,$2,$4])  }
pass1/parser/grammar.edit.y:        { $$ := mknode([EXPORTELEMENT,$1,$2,$3]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([ALLCONSTANTS]) }
pass1/parser/grammar.edit.y:		p := mknode([BLOCKDENOTATION, emptylist(), $2])
pass1/parser/grammar.edit.y:		ge1 := mknode([GUARDEDELEMENT,$2,first($4)])
pass1/parser/grammar.edit.y:		ge1 := mknode([GUARDEDELEMENT,$2,
pass1/parser/grammar.edit.y:			    mknode([BLOCKDENOTATION,emptylist(),$4])])
pass1/parser/grammar.edit.y:		    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), $5])
pass1/parser/grammar.edit.y:	    $$ := mknode([GUARDEDLIST, mklist([ge1, ge2])])
pass1/parser/grammar.edit.y:		ge1 := mknode([GUARDEDELEMENT,$1,first($3)])
pass1/parser/grammar.edit.y:		ge1 := mknode([GUARDEDELEMENT,$1,
pass1/parser/grammar.edit.y:			    mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.edit.y:	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), $4])
pass1/parser/grammar.edit.y:		$$ := mknode([GUARDEDELEMENT,$1,first($3)])
pass1/parser/grammar.edit.y:		p := mknode([GUARDEDELEMENT,$1,
pass1/parser/grammar.edit.y:				mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.edit.y:        { $$ := mknode([LETTERID,$1]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([OPRID,$1]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([QSTR,$1]) }
pass1/parser/grammar.edit.y:        { $$ := mknode([UQSTR,$1]) }
pass1/parser/grammar.fixed.tmp.icn:        {  yyval := mklist([ mknode([PARAMETER,nil,valstk[1]]) ])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([VARSIGNATURE,valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([VALSIGNATURE,valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[10],valstk[9],valstk[8],valstk[6]])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[9],valstk[8],valstk[7],nil])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[8],valstk[7],valstk[6],nil])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[6],nil,nil,nil])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:          vl_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.fixed.tmp.icn:                                mklist([mknode([PARAMETER,
pass1/parser/grammar.fixed.tmp.icn:                                              mknode([VALSIGNATURE,
pass1/parser/grammar.fixed.tmp.icn:                                                     mknode([LETTERID])])])
pass1/parser/grammar.fixed.tmp.icn:                                mknode([VALSIGNATURE, valstk[1]])])
pass1/parser/grammar.fixed.tmp.icn:            vr_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.fixed.tmp.icn:                                  mklist([mknode([PARAMETER,
pass1/parser/grammar.fixed.tmp.icn:                                                mknode([VARSIGNATURE,
pass1/parser/grammar.fixed.tmp.icn:                                                       mknode([LETTERID])])])
pass1/parser/grammar.fixed.tmp.icn:                                  mknode([VARSIGNATURE, valstk[1]])])
pass1/parser/grammar.fixed.tmp.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_assign])
pass1/parser/grammar.fixed.tmp.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_less])
pass1/parser/grammar.fixed.tmp.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_greater])
pass1/parser/grammar.fixed.tmp.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_equals])
pass1/parser/grammar.fixed.tmp.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_sconc])
pass1/parser/grammar.fixed.tmp.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_pconc])
pass1/parser/grammar.fixed.tmp.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_New])
pass1/parser/grammar.fixed.tmp.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_ValueOf])
pass1/parser/grammar.fixed.tmp.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_const])
pass1/parser/grammar.fixed.tmp.icn:		yyval := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3])])
pass1/parser/grammar.fixed.tmp.icn:		yyval := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
pass1/parser/grammar.fixed.tmp.icn: yyval := mknode([WORDCAND])
pass1/parser/grammar.fixed.tmp.icn: yyval := mknode([WORDCOR])
pass1/parser/grammar.fixed.tmp.icn: yyval := mknode([MODPRIMARY,valstk[2],valstk[1],nil])
pass1/parser/grammar.fixed.tmp.icn:	      yyval := p := mknode([BLOCKDENOTATION,emptylist(),valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([GUARDEDLIST,valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([LOOPDENOTATION,valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := p := mknode([BLOCKDENOTATION,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := p := mknode([USELIST,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([REXTERNDEF, read_signature(valstk[2]), valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:	      yyval := mknode([FUNCCONSTR,valstk[4],first(valstk[2])])
pass1/parser/grammar.fixed.tmp.icn:	      yyval := mknode([FUNCCONSTR,valstk[4],
pass1/parser/grammar.fixed.tmp.icn:			      mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([FUNCCONSTR, valstk[5], mknode([EXTERNDEF, valstk[2]])])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])
pass1/parser/grammar.fixed.tmp.icn:	{ yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([WORDELSE])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([ENUMERATION,valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([EXTENSION,valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:	  yyval := mknode([PRODCONSTRUCTION,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([RECORDCONSTRUCTION,valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:          yyval := mknode([UNIONCONSTRUCTION,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:	{ yyval := mknode([WITHLIST,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:	{ yyval := mknode([valstk[5],valstk[4],valstk[2]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([EXPORTELEMENT,valstk[3],valstk[2],valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([ALLCONSTANTS])
pass1/parser/grammar.fixed.tmp.icn:		p := mknode([BLOCKDENOTATION, emptylist(), valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
pass1/parser/grammar.fixed.tmp.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],
pass1/parser/grammar.fixed.tmp.icn:			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.fixed.tmp.icn:		    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:	    yyval := mknode([GUARDEDLIST, mklist([ge1, ge2])])
pass1/parser/grammar.fixed.tmp.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
pass1/parser/grammar.fixed.tmp.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],
pass1/parser/grammar.fixed.tmp.icn:			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.fixed.tmp.icn:	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:		yyval := mknode([GUARDEDELEMENT,valstk[3],first(valstk[1])])
pass1/parser/grammar.fixed.tmp.icn:		p := mknode([GUARDEDELEMENT,valstk[3],
pass1/parser/grammar.fixed.tmp.icn:				mknode([BLOCKDENOTATION,emptylist(),valstk[1]])])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([LETTERID,valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([OPRID,valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([QSTR,valstk[1]])
pass1/parser/grammar.fixed.tmp.icn:        { yyval := mknode([UQSTR,valstk[1]])
pass1/parser/initids.tmp.icn:        id_Boolean := mknode([LETTERID, indx_Boolean])
pass1/parser/initids.tmp.icn:        id_Void := mknode([LETTERID, indx_Void])
pass1/parser/initids.tmp.icn:	id_Integer := mknode([LETTERID, indx_Integer])
pass1/parser/initids.tmp.icn:	id_put := mknode([LETTERID, indx_put])
pass1/parser/initids.tmp.icn:	id_ValueOf := mknode([LETTERID, indx_ValueOf])
pass1/parser/initids.tmp.icn:	id_New := mknode([LETTERID, indx_New])
pass1/parser/initids.tmp.icn:	id_size := mknode([LETTERID, indx_size])
pass1/parser/initids.tmp.icn:	id_Null := mknode([LETTERID, indx_Null])
pass1/parser/initids.tmp.icn:	id_times := mknode([LETTERID, indx_times])
pass1/parser/initids.tmp.icn:	id_plus := mknode([LETTERID, indx_plus])
pass1/parser/initids.tmp.icn:        val_Boolean := lock( mknode([VALSIGNATURE,
pass1/parser/initids.tmp.icn:	val_Integer := lock( mknode([VALSIGNATURE,
pass1/parser/initids.tmp.icn:        val_Void    := lock( mknode([VALSIGNATURE,
pass1/parser/initids.tmp.icn:        var_Void    := lock( mknode([VARSIGNATURE,
pass1/parser/initids.tmp.icn:        val_param := lock( mknode([PARAMETER,
pass1/parser/initids.tmp.icn:                                 mknode([VALSIGNATURE,
pass1/parser/initids.tmp.icn:                                        mknode([LETTERID])
pass1/parser/initids.tmp.icn:        var_param := lock( mknode([PARAMETER,
pass1/parser/initids.tmp.icn:                                 mknode([VARSIGNATURE,
pass1/parser/initids.tmp.icn:                                        mknode([LETTERID])
pass1/parser/initids.tmp.icn:	sig_assign := lock( mknode([FUNCSIGNATURE, nil, as_params,
pass1/parser/initids.tmp.icn:	    lock( mknode([FUNCSIGNATURE, nil, two_params,
pass1/parser/initids.tmp.icn:	    lock( mknode([FUNCSIGNATURE, nil, two_params,val_Boolean]) )
pass1/parser/initids.tmp.icn:	sig_New := lock( mknode([FUNCSIGNATURE, nil, emptylist(),
pass1/parser/initids.tmp.icn:	sig_const := lock( mknode([FUNCSIGNATURE, nil, emptylist(),
pass1/parser/initids.tmp.icn:	sig_ValueOf := lock( mknode([FUNCSIGNATURE, nil,
pass1/parser/initids.tmp.icn:	sig_Signature := lock(mknode([SIGNATURESIG]))
pass1/parser/initids.tmp.icn:        sel_true := mknode([LETTERID,indx_true])
pass1/parser/initids.tmp.icn:        sel_true := mknode([APPLICATION, sel_true, emptylist()])
pass1/parser/initids.tmp.icn:        sel_false := mknode([LETTERID,indx_false])
pass1/parser/initids.tmp.icn:        sel_false := mknode([APPLICATION, sel_false, emptylist()])
pass1/parser/initids.tmp.icn:	appl_Null := mknode([APPLICATION, id_Null, emptylist()])
pass1/parser/grammar.new.y:        {  $$ := mklist([ mknode([PARAMETER,nil,$1]) ]) }
pass1/parser/grammar.new.y:	  $$ := mknode([VARSIGNATURE,$2])
pass1/parser/grammar.new.y:	  $$ := mknode([VALSIGNATURE,$2])
pass1/parser/grammar.new.y:	  $$ := mknode([TYPESIGNATURE,$11,$13,$5,$6,$7,$9])
pass1/parser/grammar.new.y:	  $$ := mknode([TYPESIGNATURE,$10,$12,$5,$6,$7,nil])
pass1/parser/grammar.new.y:	  $$ := mknode([TYPESIGNATURE,$9,$11,$5,$6,$7,nil])
pass1/parser/grammar.new.y:	  $$ := mknode([TYPESIGNATURE,$7,$9,$5,nil,nil,nil])
pass1/parser/grammar.new.y:	  $$ := mknode([TYPESIGNATURE,$5,$7,nil,nil,nil,nil])
pass1/parser/grammar.new.y:	  $$ := mknode([TYPESIGNATURE,$2,$4,nil,nil,nil,nil])
pass1/parser/grammar.new.y:	  $$ := mknode([FUNCSIGNATURE,$3,$5,$7])
pass1/parser/grammar.new.y:	  $$ := mknode([FUNCSIGNATURE,$2,$4,$6])
pass1/parser/grammar.new.y:          vl_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.new.y:                                mklist([mknode([PARAMETER,
pass1/parser/grammar.new.y:                                              mknode([VALSIGNATURE,
pass1/parser/grammar.new.y:                                                     mknode([LETTERID])])])
pass1/parser/grammar.new.y:                                mknode([VALSIGNATURE, $5])])
pass1/parser/grammar.new.y:            vr_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.new.y:                                  mklist([mknode([PARAMETER,
pass1/parser/grammar.new.y:                                                mknode([VARSIGNATURE,
pass1/parser/grammar.new.y:                                                       mknode([LETTERID])])])
pass1/parser/grammar.new.y:                                  mknode([VARSIGNATURE, $5])])
pass1/parser/grammar.new.y:                        result := mknode([TSCOMPONENT,$1,sig_assign])
pass1/parser/grammar.new.y:                        result := mknode([TSCOMPONENT,$1,sig_less])
pass1/parser/grammar.new.y:                        result := mknode([TSCOMPONENT,$1,sig_greater])
pass1/parser/grammar.new.y:			result := mknode([TSCOMPONENT,$1,sig_equals])
pass1/parser/grammar.new.y:			result := mknode([TSCOMPONENT,$1,sig_sconc])
pass1/parser/grammar.new.y:			result := mknode([TSCOMPONENT,$1,sig_pconc])
pass1/parser/grammar.new.y:                        result := mknode([TSCOMPONENT,$1,sig_New])
pass1/parser/grammar.new.y:                        result := mknode([TSCOMPONENT,$1,sig_ValueOf])
pass1/parser/grammar.new.y:                        result := mknode([TSCOMPONENT,$1,sig_const])
pass1/parser/grammar.new.y:		$$ := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3])])
pass1/parser/grammar.new.y:		$$ := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
pass1/parser/grammar.new.y:        { $$ := mknode([WORDCAND]) }
pass1/parser/grammar.new.y:        { $$ := mknode([WORDCOR]) }
pass1/parser/grammar.new.y:	{ $$ := mknode([MODPRIMARY,$1,$2,nil]) }
pass1/parser/grammar.new.y:	      $$ := p := mknode([BLOCKDENOTATION,emptylist(),$2])
pass1/parser/grammar.new.y:        { $$ := mknode([GUARDEDLIST,$2]) }
pass1/parser/grammar.new.y:        { $$ := mknode([LOOPDENOTATION,$2]) }
pass1/parser/grammar.new.y:	  $$ := p := mknode([BLOCKDENOTATION,$2,$4])
pass1/parser/grammar.new.y:	  $$ := p := mknode([USELIST,$2,$4])
pass1/parser/grammar.new.y:	  $$ := mknode([REXTERNDEF, read_signature($3), $3])
pass1/parser/grammar.new.y:	      $$ := mknode([FUNCCONSTR,$1,first($3)])
pass1/parser/grammar.new.y:	      $$ := mknode([FUNCCONSTR,$1,
pass1/parser/grammar.new.y:			      mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.new.y:	  $$ := mknode([FUNCCONSTR, $1, mknode([EXTERNDEF, $4])])
pass1/parser/grammar.new.y:	  $$ := mknode([FUNCSIGNATURE, $3, $5, nil])
pass1/parser/grammar.new.y:	{ $$ := mknode([FUNCSIGNATURE, $2, $4, nil]) }
pass1/parser/grammar.new.y:        { $$ := mknode([WORDELSE]) }
pass1/parser/grammar.new.y:        { $$ := mknode([ENUMERATION,$3]) }
pass1/parser/grammar.new.y:        { $$ := mknode([EXTENSION,$3]) }
pass1/parser/grammar.new.y:	  $$ := mknode([PRODCONSTRUCTION,$2,$4]) 
pass1/parser/grammar.new.y:        { $$ := mknode([RECORDCONSTRUCTION,$3]) }
pass1/parser/grammar.new.y:          $$ := mknode([UNIONCONSTRUCTION,$2,$4])
pass1/parser/grammar.new.y:	{ $$ := mknode([WITHLIST,$2,$4]) }
pass1/parser/grammar.new.y:	{ $$ := mknode([$1,$2,$4])  }
pass1/parser/grammar.new.y:        { $$ := mknode([EXPORTELEMENT,$1,$2,$3]) }
pass1/parser/grammar.new.y:        { $$ := mknode([ALLCONSTANTS]) }
pass1/parser/grammar.new.y:		p := mknode([BLOCKDENOTATION, emptylist(), $2])
pass1/parser/grammar.new.y:		ge1 := mknode([GUARDEDELEMENT,$2,first($4)])
pass1/parser/grammar.new.y:		ge1 := mknode([GUARDEDELEMENT,$2,
pass1/parser/grammar.new.y:			    mknode([BLOCKDENOTATION,emptylist(),$4])])
pass1/parser/grammar.new.y:		    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), $5])
pass1/parser/grammar.new.y:	    $$ := mknode([GUARDEDLIST, mklist([ge1, ge2])])
pass1/parser/grammar.new.y:		ge1 := mknode([GUARDEDELEMENT,$1,first($3)])
pass1/parser/grammar.new.y:		ge1 := mknode([GUARDEDELEMENT,$1,
pass1/parser/grammar.new.y:			    mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.new.y:	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), $4])
pass1/parser/grammar.new.y:		$$ := mknode([GUARDEDELEMENT,$1,first($3)])
pass1/parser/grammar.new.y:		p := mknode([GUARDEDELEMENT,$1,
pass1/parser/grammar.new.y:				mknode([BLOCKDENOTATION,emptylist(),$3])])
pass1/parser/grammar.new.y:        { $$ := mknode([LETTERID,$1]) }
pass1/parser/grammar.new.y:        { $$ := mknode([OPRID,$1]) }
pass1/parser/grammar.new.y:        { $$ := mknode([QSTR,$1]) }
pass1/parser/grammar.new.y:        { $$ := mknode([UQSTR,$1]) }
pass1/parser/grammar.icn:        {  yyval := mklist([ mknode([PARAMETER,nil,valstk[1]]) ]) 
pass1/parser/grammar.icn:	  yyval := mknode([VARSIGNATURE,valstk[1]])
pass1/parser/grammar.icn:	  yyval := mknode([VALSIGNATURE,valstk[1]])
pass1/parser/grammar.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[10],valstk[9],valstk[8],valstk[6]])
pass1/parser/grammar.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[9],valstk[8],valstk[7],nil])
pass1/parser/grammar.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[8],valstk[7],valstk[6],nil])
pass1/parser/grammar.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[6],nil,nil,nil])
pass1/parser/grammar.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
pass1/parser/grammar.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
pass1/parser/grammar.icn:	  yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
pass1/parser/grammar.icn:	  yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
pass1/parser/grammar.icn:          vl_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.icn:                                mklist([mknode([PARAMETER,
pass1/parser/grammar.icn:                                              mknode([VALSIGNATURE,
pass1/parser/grammar.icn:                                                     mknode([LETTERID])])])
pass1/parser/grammar.icn:                                mknode([VALSIGNATURE, valstk[1]])])
pass1/parser/grammar.icn:            vr_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.icn:                                  mklist([mknode([PARAMETER,
pass1/parser/grammar.icn:                                                mknode([VARSIGNATURE,
pass1/parser/grammar.icn:                                                       mknode([LETTERID])])])
pass1/parser/grammar.icn:                                  mknode([VARSIGNATURE, valstk[1]])])
pass1/parser/grammar.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_assign])
pass1/parser/grammar.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_less])
pass1/parser/grammar.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_greater])
pass1/parser/grammar.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_equals])
pass1/parser/grammar.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_sconc])
pass1/parser/grammar.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_pconc])
pass1/parser/grammar.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_New])
pass1/parser/grammar.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_ValueOf])
pass1/parser/grammar.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_const])
pass1/parser/grammar.icn:		yyval := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3])])
pass1/parser/grammar.icn:		yyval := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
pass1/parser/grammar.icn: yyval := mknode([WORDCAND]) 
pass1/parser/grammar.icn: yyval := mknode([WORDCOR]) 
pass1/parser/grammar.icn: yyval := mknode([MODPRIMARY,valstk[2],valstk[1],nil]) 
pass1/parser/grammar.icn:	      yyval := p := mknode([BLOCKDENOTATION,emptylist(),valstk[2]])
pass1/parser/grammar.icn:        { yyval := mknode([GUARDEDLIST,valstk[2]]) 
pass1/parser/grammar.icn:        { yyval := mknode([LOOPDENOTATION,valstk[2]]) 
pass1/parser/grammar.icn:	  yyval := p := mknode([BLOCKDENOTATION,valstk[4],valstk[2]])
pass1/parser/grammar.icn:	  yyval := p := mknode([USELIST,valstk[4],valstk[2]])
pass1/parser/grammar.icn:	  yyval := mknode([REXTERNDEF, read_signature(valstk[2]), valstk[2]])
pass1/parser/grammar.icn:	      yyval := mknode([FUNCCONSTR,valstk[4],first(valstk[2])])
pass1/parser/grammar.icn:	      yyval := mknode([FUNCCONSTR,valstk[4],
pass1/parser/grammar.icn:			      mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.icn:	  yyval := mknode([FUNCCONSTR, valstk[5], mknode([EXTERNDEF, valstk[2]])])
pass1/parser/grammar.icn:	  yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])
pass1/parser/grammar.icn:	{ yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil]) 
pass1/parser/grammar.icn:        { yyval := mknode([WORDELSE]) 
pass1/parser/grammar.icn:        { yyval := mknode([ENUMERATION,valstk[2]]) 
pass1/parser/grammar.icn:        { yyval := mknode([EXTENSION,valstk[2]]) 
pass1/parser/grammar.icn:	  yyval := mknode([PRODCONSTRUCTION,valstk[4],valstk[2]]) 
pass1/parser/grammar.icn:        { yyval := mknode([RECORDCONSTRUCTION,valstk[2]]) 
pass1/parser/grammar.icn:          yyval := mknode([UNIONCONSTRUCTION,valstk[4],valstk[2]])
pass1/parser/grammar.icn:	{ yyval := mknode([WITHLIST,valstk[4],valstk[2]]) 
pass1/parser/grammar.icn:	{ yyval := mknode([valstk[5],valstk[4],valstk[2]])  
pass1/parser/grammar.icn:        { yyval := mknode([EXPORTELEMENT,valstk[3],valstk[2],valstk[1]]) 
pass1/parser/grammar.icn:        { yyval := mknode([ALLCONSTANTS]) 
pass1/parser/grammar.icn:		p := mknode([BLOCKDENOTATION, emptylist(), valstk[1]])
pass1/parser/grammar.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
pass1/parser/grammar.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],
pass1/parser/grammar.icn:			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.icn:		    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
pass1/parser/grammar.icn:	    yyval := mknode([GUARDEDLIST, mklist([ge1, ge2])])
pass1/parser/grammar.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
pass1/parser/grammar.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],
pass1/parser/grammar.icn:			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.icn:	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
pass1/parser/grammar.icn:		yyval := mknode([GUARDEDELEMENT,valstk[3],first(valstk[1])])
pass1/parser/grammar.icn:		p := mknode([GUARDEDELEMENT,valstk[3],
pass1/parser/grammar.icn:				mknode([BLOCKDENOTATION,emptylist(),valstk[1]])])
pass1/parser/grammar.icn:        { yyval := mknode([LETTERID,valstk[1]]) 
pass1/parser/grammar.icn:        { yyval := mknode([OPRID,valstk[1]]) 
pass1/parser/grammar.icn:        { yyval := mknode([QSTR,valstk[1]]) 
pass1/parser/grammar.icn:        { yyval := mknode([UQSTR,valstk[1]]) 
pass1/parser/grammar.fixed.icn:        {  yyval := mklist([ mknode([PARAMETER,nil,valstk[1]]) ])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([VARSIGNATURE,valstk[1]])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([VALSIGNATURE,valstk[1]])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[10],valstk[9],valstk[8],valstk[6]])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[9],valstk[8],valstk[7],nil])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[8],valstk[7],valstk[6],nil])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[6],nil,nil,nil])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
pass1/parser/grammar.fixed.icn:          vl_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.fixed.icn:                                mklist([mknode([PARAMETER,
pass1/parser/grammar.fixed.icn:                                              mknode([VALSIGNATURE,
pass1/parser/grammar.fixed.icn:                                                     mknode([LETTERID])])])
pass1/parser/grammar.fixed.icn:                                mknode([VALSIGNATURE, valstk[1]])])
pass1/parser/grammar.fixed.icn:            vr_field_sig := mknode([FUNCSIGNATURE,
pass1/parser/grammar.fixed.icn:                                  mklist([mknode([PARAMETER,
pass1/parser/grammar.fixed.icn:                                                mknode([VARSIGNATURE,
pass1/parser/grammar.fixed.icn:                                                       mknode([LETTERID])])])
pass1/parser/grammar.fixed.icn:                                  mknode([VARSIGNATURE, valstk[1]])])
pass1/parser/grammar.fixed.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_assign])
pass1/parser/grammar.fixed.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_less])
pass1/parser/grammar.fixed.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_greater])
pass1/parser/grammar.fixed.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_equals])
pass1/parser/grammar.fixed.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_sconc])
pass1/parser/grammar.fixed.icn:			result := mknode([TSCOMPONENT,valstk[1],sig_pconc])
pass1/parser/grammar.fixed.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_New])
pass1/parser/grammar.fixed.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_ValueOf])
pass1/parser/grammar.fixed.icn:                        result := mknode([TSCOMPONENT,valstk[1],sig_const])
pass1/parser/grammar.fixed.icn:		yyval := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3])])
pass1/parser/grammar.fixed.icn:		yyval := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
pass1/parser/grammar.fixed.icn: yyval := mknode([WORDCAND])
pass1/parser/grammar.fixed.icn: yyval := mknode([WORDCOR])
pass1/parser/grammar.fixed.icn: yyval := mknode([MODPRIMARY,valstk[2],valstk[1],nil])
pass1/parser/grammar.fixed.icn:	      yyval := p := mknode([BLOCKDENOTATION,emptylist(),valstk[2]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([GUARDEDLIST,valstk[2]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([LOOPDENOTATION,valstk[2]])
pass1/parser/grammar.fixed.icn:	  yyval := p := mknode([BLOCKDENOTATION,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.icn:	  yyval := p := mknode([USELIST,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([REXTERNDEF, read_signature(valstk[2]), valstk[2]])
pass1/parser/grammar.fixed.icn:	      yyval := mknode([FUNCCONSTR,valstk[4],first(valstk[2])])
pass1/parser/grammar.fixed.icn:	      yyval := mknode([FUNCCONSTR,valstk[4],
pass1/parser/grammar.fixed.icn:			      mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([FUNCCONSTR, valstk[5], mknode([EXTERNDEF, valstk[2]])])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])
pass1/parser/grammar.fixed.icn:	{ yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([WORDELSE])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([ENUMERATION,valstk[2]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([EXTENSION,valstk[2]])
pass1/parser/grammar.fixed.icn:	  yyval := mknode([PRODCONSTRUCTION,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([RECORDCONSTRUCTION,valstk[2]])
pass1/parser/grammar.fixed.icn:          yyval := mknode([UNIONCONSTRUCTION,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.icn:	{ yyval := mknode([WITHLIST,valstk[4],valstk[2]])
pass1/parser/grammar.fixed.icn:	{ yyval := mknode([valstk[5],valstk[4],valstk[2]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([EXPORTELEMENT,valstk[3],valstk[2],valstk[1]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([ALLCONSTANTS])
pass1/parser/grammar.fixed.icn:		p := mknode([BLOCKDENOTATION, emptylist(), valstk[1]])
pass1/parser/grammar.fixed.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
pass1/parser/grammar.fixed.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],
pass1/parser/grammar.fixed.icn:			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.fixed.icn:		    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
pass1/parser/grammar.fixed.icn:	    yyval := mknode([GUARDEDLIST, mklist([ge1, ge2])])
pass1/parser/grammar.fixed.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
pass1/parser/grammar.fixed.icn:		ge1 := mknode([GUARDEDELEMENT,valstk[4],
pass1/parser/grammar.fixed.icn:			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
pass1/parser/grammar.fixed.icn:	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
pass1/parser/grammar.fixed.icn:		yyval := mknode([GUARDEDELEMENT,valstk[3],first(valstk[1])])
pass1/parser/grammar.fixed.icn:		p := mknode([GUARDEDELEMENT,valstk[3],
pass1/parser/grammar.fixed.icn:				mknode([BLOCKDENOTATION,emptylist(),valstk[1]])])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([LETTERID,valstk[1]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([OPRID,valstk[1]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([QSTR,valstk[1]])
pass1/parser/grammar.fixed.icn:        { yyval := mknode([UQSTR,valstk[1]])
pass2/symtabtest.c:	mknode(BLOCKDENOTATION,
pass2/symtabtest.c:			mklist( mknode(DECLARATION,
pass2/symtabtest.c:							mknode(LETTERID, stt_enter("first", 6), NIL),
pass2/symtabtest.c:					mknode(DECLARATION,
pass2/symtabtest.c:							mknode(LETTERID, stt_enter("second", 7), NIL),
pass2/symtabtest.c:					mknode(DECLARATION,
pass2/symtabtest.c:							mknode(LETTERID, stt_enter("second", 7), NIL),
pass3/tsig_order.c:    constants = lock(mknode(DEFCHARSIGS,0,0,0,0));
pass3/tsig_order.c:    NODE * new_node = mknode(DCSEXCEPTION);
pass3/expand_str.c:                id_node = mknode(LETTERID, indx_empty);
pass3/expand_str.c:		id_node = mknode(LETTERID, stt_enter(const_template,4));
pass3/expand_str.c:    expansion = mknode(APPLICATION, id_node, emptylist());
pass3/expand_str.c:		    conc_op = mknode(LETTERID, indx_sconc);
pass3/expand_str.c:		    conc_op = mknode(LETTERID, indx_pconc);
pass3/expand_str.c:	    id_node = mknode(LETTERID, stt_enter(const_template,4));
pass3/expand_str.c:            expansion = mknode( APPLICATION,
pass3/expand_str.c:                                        mknode( APPLICATION,
pass3/tsig_order.icn:    constants = lock(mknode([DEFCHARSIGS,0,0,0,0]))
pass3/tsig_order.icn:    NODE * new_node = mknode(DCSEXCEPTION);
pass3/tsig_order.tmp.icn:    constants = lock(mknode([DEFCHARSIGS,0,0,0,0]))
pass3/tsig_order.tmp.icn:#     NODE * new_node = mknode(DCSEXCEPTION);
pass4/infer_args.c:NODE * mknode();
pass4/infer_args.c:        new_str = mknode(UQSTR, new_str_string);
pass4/infer_args.c:	    dummy_id = mknode(LETTERID, DUMMY);
pass4/infer_args.c:        Void_id = lock(mknode(LETTERID, 0));
pass4/coerce.c:		nop = mknode(LETTERID, indx_ValueOf);
pass4/coerce.c:		nappl = mknode(APPLICATION, nop, mklist(p, -1));
pass4/coerce.c:		nappl = mknode(APPLICATION, p, emptylist());
pass4/findsig.c:                        NODE * nresult = mknode(MODPRIMARY,
pass4/findsig.c:                        initsig(p, mknode(VALSIGNATURE, p -> sel_type));
pass4/findsig.c:					mknode(LETTERID, UNDEFNAME)
pass4/findsig.c:		    NODE * self = mknode(VALSIGNATURE, local_id);
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:				   mknode(FUNCSIGNATURE, NIL,
pass4/findsig.c:                        addright(par, t = mknode(PARAMETER, NIL, self));
pass4/findsig.c:			addright(arg, t = mknode(LETTERID, UNDEFNAME));
pass4/findsig.c:			  r = mknode(APPLICATION, r, arg);
pass4/findsig.c:			r = mknode(FUNCSIGNATURE,
pass4/findsig.c:			r = mknode(TSCOMPONENT, s -> par_id, r);
pass4/findsig.c:		    initsig(p, mknode(TYPESIGNATURE,
pass4/findsig.c:					mknode(LETTERID, UNDEFNAME)
pass4/findsig.c:		    NODE * self = mknode(VALSIGNATURE, local_id);
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:                        addright(par, t = mknode(PARAMETER, NIL, self));
pass4/findsig.c:			  r = mknode(FUNCSIGNATURE,
pass4/findsig.c:				   mknode(TSCOMPONENT,
pass4/findsig.c:			  r = mknode(FUNCSIGNATURE,
pass4/findsig.c:				   mknode(TSCOMPONENT,
pass4/findsig.c:			  r = mknode(FUNCSIGNATURE,
pass4/findsig.c:				     mklist( mknode(PARAMETER,
pass4/findsig.c:				   mknode(TSCOMPONENT,
pass4/findsig.c:		    initsig(p, mknode(TYPESIGNATURE, NIL,
pass4/findsig.c:		    NODE * local_id = mknode(LETTERID, -1);
pass4/findsig.c:		    NODE * self = mknode(VALSIGNATURE, local_id);
pass4/findsig.c:		    NODE * self_param = mknode(PARAMETER, NIL, self);
pass4/findsig.c:		    NODE * Int_param = mknode(PARAMETER, NIL, val_Integer);
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:				   mknode(FUNCSIGNATURE,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:				   mknode(FUNCSIGNATURE,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:				   mknode(FUNCSIGNATURE,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:				   mknode(FUNCSIGNATURE,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:				   mknode(FUNCSIGNATURE,
pass4/findsig.c:				   mknode(TSCOMPONENT, s, r)
pass4/findsig.c:		    initsig(p, mknode(TYPESIGNATURE, NIL,
pass4/findsig.c:			local_id = mknode(LETTERID, UNDEFNAME);
pass4/findsig.c:                      id_In = mknode(LETTERID, indx_In);
pass4/findsig.c:                      id_Out = mknode(LETTERID, indx_Out);
pass4/findsig.c:                      orig_sig = mknode(VALSIGNATURE, p -> ext_denotation);
pass4/findsig.c:                      new_sig = mknode(VALSIGNATURE, mknode(LETTERID, -1));
pass4/findsig.c:                      par_list = mklist(mknode(PARAMETER, NIL, orig_sig), -1);
pass4/findsig.c:                      In_sig = mknode(FUNCSIGNATURE,
pass4/findsig.c:                      par_list = mklist(mknode(PARAMETER, NIL, new_sig), -1);
pass4/findsig.c:                      Out_sig = mknode(FUNCSIGNATURE,
pass4/findsig.c:		    NODE * local_id = mknode(LETTERID, -1);
pass4/findsig.c:		    NODE * self = mknode(VALSIGNATURE, local_id);
pass4/findsig.c:		    NODE * self_param = mknode(PARAMETER, NIL, self);
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:                        r = mknode(VALSIGNATURE, s -> re_denotation);
pass4/findsig.c:                        r = mknode(PARAMETER, NIL, r);
pass4/findsig.c:                      r = mknode(FUNCSIGNATURE, NIL,
pass4/findsig.c:                      r = mknode(TSCOMPONENT,
pass4/findsig.c:                             mknode(FUNCSIGNATURE,
pass4/findsig.c:                                    mknode(VALSIGNATURE,
pass4/findsig.c:                        r = mklist(mknode(PARAMETER,
pass4/findsig.c:                                          mknode(VARSIGNATURE,local_id)),
pass4/findsig.c:                             mknode(FUNCSIGNATURE,
pass4/findsig.c:                                    mknode(VARSIGNATURE,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:			r = mknode(TSCOMPONENT,
pass4/findsig.c:                    initsig(p, mknode(TYPESIGNATURE, NIL,
pass4/findapplsig.c:			  NODE * narg = mknode( MODPRIMARY,
pass4/getcomp.c:	    ntid = mknode(LETTERID, 0);
pass4/getcomp.c:	    new_tsc = mknode(TSCOMPONENT, id, NIL);
pass4/findmpsig.c:            new_id = mknode(LETTERID, UNDEFNAME);
pass4/findsig.tmp.icn:			    nresult := mknode([MODPRIMARY,
pass4/findsig.tmp.icn:		    local_id := mknode([LETTERID, UNDEFNAME])
pass4/findsig.tmp.icn:		self_it := mknode([VALSIGNATURE, local_id])
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r = mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			     mknode([FUNCSIGNATURE, nil,
pass4/findsig.tmp.icn:		    addright(par, t := mknode([PARAMETER, nil, self_it]))
pass4/findsig.tmp.icn:		    addright(arg, t := mknode([LETTERID, UNDEFNAME]))
pass4/findsig.tmp.icn:			r := mknode([APPLICATION, r, arg])
pass4/findsig.tmp.icn:			r := mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:			r := mknode([TSCOMPONENT, s . par_id, r])
pass4/findsig.tmp.icn:		initsig(p, mknode([TYPESIGNATURE,
pass4/findsig.tmp.icn:			local_id := mknode([LETTERID, UNDEFNAME])
pass4/findsig.tmp.icn:		    self_it = mknode([VALSIGNATURE, local_id])
pass4/findsig.tmp.icn:		    r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		    r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		    r = mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			addright(par, t := mknode([PARAMETER, nil, self]))
pass4/findsig.tmp.icn:			    r = mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:				     mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			    r := mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:				     mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			    r := mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:					 mklist([ mknode(PARAMETER,
pass4/findsig.tmp.icn:				     mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		initsig(p, mknode([TYPESIGNATURE, nil,comp_list,nil, nil, nil]))
pass4/findsig.tmp.icn:		local_id := mknode([LETTERID, -1])
pass4/findsig.tmp.icn:		self_it = mknode([VALSIGNATURE, local_id])
pass4/findsig.tmp.icn:		self_param := mknode([PARAMETER, nil, self_it])
pass4/findsig.tmp.icn:		Int_param := mknode([PARAMETER, nil, val_Integer])
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:			addright(comp_list, mknode([TSCOMPONENT, s, r]))
pass4/findsig.tmp.icn:		initsig(p, mknode([TYPESIGNATURE, nil,
pass4/findsig.tmp.icn:		    local_id := mknode([LETTERID, UNDEFNAME])
pass4/findsig.tmp.icn:		id_In = mknode([LETTERID, indx_In])
pass4/findsig.tmp.icn:		id_Out = mknode([LETTERID, indx_Out])
pass4/findsig.tmp.icn:		orig_sig := mknode([VALSIGNATURE, p . ext_denotation])
pass4/findsig.tmp.icn:		new_sig := mknode([VALSIGNATURE, mknode([LETTERID, -1])])
pass4/findsig.tmp.icn:		par_list := mklist([mknode([PARAMETER, nil, orig_sig])])
pass4/findsig.tmp.icn:		In_sig := mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:		par_list := mklist([mknode([PARAMETER, nil, new_sig])]);
pass4/findsig.tmp.icn:		Out_sig := mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:		local_id := mknode([LETTERID, -1])
pass4/findsig.tmp.icn:		self := mknode([VALSIGNATURE, local_id])
pass4/findsig.tmp.icn:		self_param := mknode([PARAMETER, nil, self_it])
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		r = mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		    r := mknode([VALSIGNATURE, s . re_denotation])
pass4/findsig.tmp.icn:		    r = mknode([PARAMETER, nil, r])
pass4/findsig.tmp.icn:		r = mknode([FUNCSIGNATURE, nil,
pass4/findsig.tmp.icn:		r = mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		    vl_field_sig := mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:					    mknode([VALSIGNATURE,
pass4/findsig.tmp.icn:		    r := mklist([mknode([PARAMETER,
pass4/findsig.tmp.icn:					 mknode([VARSIGNATURE,local_id])])])
pass4/findsig.tmp.icn:		    vr_field_sig :=  mknode([FUNCSIGNATURE,
pass4/findsig.tmp.icn:					     mknode([VARSIGNATURE,
pass4/findsig.tmp.icn:		    r := mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		    r = mknode([TSCOMPONENT,
pass4/findsig.tmp.icn:		initsig(p, mknode([TYPESIGNATURE, nil,
pass4/findapplsig.tmp.icn:			    narg := mknode( [MODPRIMARY,
pass4/getcomp.icn:	    ntid = mknode(LETTERID, 0);
pass4/getcomp.icn:	    new_tsc = mknode(TSCOMPONENT, id, NIL);
pass4/coerce.tmp.icn:		nop := mknode([LETTERID, indx_ValueOf])
pass4/coerce.tmp.icn:		nappl := mknode([APPLICATION, nop, mklist([p])])
pass4/coerce.tmp.icn:		nappl := mknode([APPLICATION, p, emptylist()])
pass4/findsig_str.inc.icn:		initsig(p, mknode([VALSIGNATURE, p . sel_type]))
pass4/findsig.icn:			    nresult := mknode([MODPRIMARY,
pass4/findsig.icn:		    local_id := mknode([LETTERID, UNDEFNAME])
pass4/findsig.icn:		self_it := mknode([VALSIGNATURE, local_id])
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r = mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:			     mknode([FUNCSIGNATURE, nil,
pass4/findsig.icn:		    addright(par, t := mknode([PARAMETER, nil, self_it]))
pass4/findsig.icn:		    addright(arg, t := mknode([LETTERID, UNDEFNAME]))
pass4/findsig.icn:			r := mknode([APPLICATION, r, arg])
pass4/findsig.icn:			r := mknode([FUNCSIGNATURE,
pass4/findsig.icn:			r := mknode([TSCOMPONENT, s . par_id, r])
pass4/findsig.icn:		initsig(p, mknode([TYPESIGNATURE,
pass4/findsig.icn:			local_id := mknode([LETTERID, UNDEFNAME])
pass4/findsig.icn:		    self_it = mknode([VALSIGNATURE, local_id])
pass4/findsig.icn:		    r := mknode([TSCOMPONENT,
pass4/findsig.icn:		    r := mknode([TSCOMPONENT,
pass4/findsig.icn:		    r = mknode([TSCOMPONENT,
pass4/findsig.icn:			addright(par, t := mknode([PARAMETER, nil, self]))
pass4/findsig.icn:			    r = mknode([FUNCSIGNATURE,
pass4/findsig.icn:				     mknode([TSCOMPONENT,
pass4/findsig.icn:			    r := mknode([FUNCSIGNATURE,
pass4/findsig.icn:				     mknode([TSCOMPONENT,
pass4/findsig.icn:			    r := mknode([FUNCSIGNATURE,
pass4/findsig.icn:					 mklist([ mknode(PARAMETER,
pass4/findsig.icn:				     mknode([TSCOMPONENT,
pass4/findsig.icn:		initsig(p, mknode([TYPESIGNATURE, nil,comp_list,nil, nil, nil]))
pass4/findsig.icn:		local_id := mknode([LETTERID, -1])
pass4/findsig.icn:		self_it = mknode([VALSIGNATURE, local_id])
pass4/findsig.icn:		self_param := mknode([PARAMETER, nil, self_it])
pass4/findsig.icn:		Int_param := mknode([PARAMETER, nil, val_Integer])
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:			     mknode([FUNCSIGNATURE,
pass4/findsig.icn:			addright(comp_list, mknode([TSCOMPONENT, s, r]))
pass4/findsig.icn:		initsig(p, mknode([TYPESIGNATURE, nil,
pass4/findsig.icn:		    local_id := mknode([LETTERID, UNDEFNAME])
pass4/findsig.icn:		id_In = mknode([LETTERID, indx_In])
pass4/findsig.icn:		id_Out = mknode([LETTERID, indx_Out])
pass4/findsig.icn:		orig_sig := mknode([VALSIGNATURE, p . ext_denotation])
pass4/findsig.icn:		new_sig := mknode([VALSIGNATURE, mknode([LETTERID, -1])])
pass4/findsig.icn:		par_list := mklist([mknode([PARAMETER, nil, orig_sig])])
pass4/findsig.icn:		In_sig := mknode([FUNCSIGNATURE,
pass4/findsig.icn:		par_list := mklist([mknode([PARAMETER, nil, new_sig])]);
pass4/findsig.icn:		Out_sig := mknode([FUNCSIGNATURE,
pass4/findsig.icn:		local_id := mknode([LETTERID, -1])
pass4/findsig.icn:		self := mknode([VALSIGNATURE, local_id])
pass4/findsig.icn:		self_param := mknode([PARAMETER, nil, self_it])
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r := mknode([TSCOMPONENT,
pass4/findsig.icn:		r = mknode([TSCOMPONENT,
pass4/findsig.icn:		    r := mknode([VALSIGNATURE, s . re_denotation])
pass4/findsig.icn:		    r = mknode([PARAMETER, nil, r])
pass4/findsig.icn:		r = mknode([FUNCSIGNATURE, nil,
pass4/findsig.icn:		r = mknode([TSCOMPONENT,
pass4/findsig.icn:		    vl_field_sig := mknode([FUNCSIGNATURE,
pass4/findsig.icn:					    mknode([VALSIGNATURE,
pass4/findsig.icn:		    r := mklist([mknode([PARAMETER,
pass4/findsig.icn:					 mknode([VARSIGNATURE,local_id])])])
pass4/findsig.icn:		    vr_field_sig :=  mknode([FUNCSIGNATURE,
pass4/findsig.icn:					     mknode([VARSIGNATURE,
pass4/findsig.icn:		    r := mknode([TSCOMPONENT,
pass4/findsig.icn:		    r = mknode([TSCOMPONENT,
pass4/findsig.icn:		initsig(p, mknode([TYPESIGNATURE, nil,
pass4/coerce.icn:		nop := mknode([LETTERID, indx_ValueOf])
pass4/coerce.icn:		nappl := mknode([APPLICATION, nop, mklist([p])])
pass4/coerce.icn:		nappl := mknode([APPLICATION, p, emptylist()])
pass4/findapplsig.icn:			    narg := mknode( [MODPRIMARY,
pass5c/bld_analyze.c:		    NODE * block = mknode(BLOCKDENOTATION,
pass5c/#bld_analyze.c#:		    NODE * block = mknode(BLOCKDENOTATION,
pass5c/appl.c:		    size_appl = mknode(APPLICATION, size_id, emptylist());
pass5c/codeutil.c:        arg_id = mknode(LETTERID, UNDEFNAME);
pass5c/codeutil.c:    appl = lock(mknode(APPLICATION, result, arg_list));
pass5c/bld_analyze.icn:		    NODE * block = mknode(BLOCKDENOTATION,
pass5c/bld_analyze.icn:		    NODE * block = mknode(BLOCKDENOTATION,
pass5c/bld_analyze.tmp.icn:# 		    NODE * block = mknode(BLOCKDENOTATION,
pass5c/bld_analyze.tmp.icn:# 		    NODE * block = mknode(BLOCKDENOTATION,
pass5d/appl.c:/* A version of maprlist (see mknode.c) that applies fn          */
pass5d/appl.c:	    size_appl = mknode(APPLICATION, size_id, emptylist());
rr:stree/mknode \
#rr#:stree/mknode \
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
russ_info.tmp:INFO: mknode va_alist
sigio/sa_sig_in.c:    result = mknode(kindno, string_index);
sigio/sa_sig_in.c:		    result = mknode(DECLARATION, id, den, sig);
sigio/sa_sig_in.c:                        v = mknode(DECLARATION, NIL, NIL, NIL);
sigio/sa_sig_in.c:                    return(mknode(BLOCKDENOTATION, decl_l, den_s));
sigio/sa_sig_in.c:                    return(mknode(APPLICATION, op, args));
sigio/sa_sig_in.c:                return(mknode(kindno, list_in(Sinfile)));
sigio/sa_sig_in.c:                    return(mknode(GUARDEDELEMENT, guard, element));
sigio/sa_sig_in.c:                    return(mknode(FUNCCONSTR, sig, body));
sigio/sa_sig_in.c:                    return(mknode(USELIST, type_list, den_seq));
sigio/sa_sig_in.c:                    NODE * result = mknode(MODPRIMARY, NIL, NIL);
sigio/sa_sig_in.c:                    NODE * result = mknode(kindno, NIL, NIL);
sigio/sa_sig_in.c:                return(mknode(WORDELSE));
sigio/sa_sig_in.c:                    return(mknode(PARAMETER, id, sig));
sigio/sa_sig_in.c:		    result = mknode(FUNCSIGNATURE,
sigio/sa_sig_in.c:                            v = mknode(PARAMETER, NIL, NIL);
sigio/sa_sig_in.c:                            constr = mknode(FUNCCONSTR,
sigio/sa_sig_in.c:					    mknode(EXTERNDEF,NIL));
sigio/sa_sig_in.c:		return(mknode(kindno, sig_in1(Sinfile)));
sigio/sa_sig_in.c:		return(mknode(SIGNATURESIG));
sigio/sa_sig_in.c:                result = mknode(TYPESIGNATURE, NIL, NIL, NIL, NIL, NIL);
sigio/sa_sig_in.c:                    return(mknode(TSCOMPONENT, id, sig));
sigio/sa_sig_in.c:		    result = mknode(DEFCHARSIGS, 0, 0, 0, 0);
sigio/sa_sig_in.c:		    result = mknode(REXTERNDEF, sig, name);
sigio/sig_in.c:    result = mknode(kindno, string_index);
sigio/sig_in.c:      result = mknode (REXTERNDEF, NIL, NIL);
sigio/sig_in.c:		    result = mknode(DECLARATION, id, den, sig);
sigio/sig_in.c:                        v = mknode(DECLARATION, NIL, NIL, NIL);
sigio/sig_in.c:                    return(mknode(BLOCKDENOTATION, decl_l, den_s));
sigio/sig_in.c:                    return(mknode(APPLICATION, op, args));
sigio/sig_in.c:                return(mknode(kindno, list_in(Sinfile)));
sigio/sig_in.c:                    return(mknode(GUARDEDELEMENT, guard, element));
sigio/sig_in.c:                    return(mknode(FUNCCONSTR, sig, body));
sigio/sig_in.c:                    return(mknode(USELIST, type_list, den_seq));
sigio/sig_in.c:                    NODE * result = mknode(MODPRIMARY, NIL, NIL);
sigio/sig_in.c:                    NODE * result = mknode(kindno, NIL, NIL);
sigio/sig_in.c:                return(mknode(WORDELSE));
sigio/sig_in.c:                    return(mknode(PARAMETER, id, sig));
sigio/sig_in.c:		    result = mknode(FUNCSIGNATURE,
sigio/sig_in.c:                            v = mknode(PARAMETER, NIL, NIL);
sigio/sig_in.c:                            constr = mknode(FUNCCONSTR,
sigio/sig_in.c:					    mknode(EXTERNDEF,NIL));
sigio/sig_in.c:		return(mknode(kindno, sig_in1(Sinfile)));
sigio/sig_in.c:		return(mknode(SIGNATURESIG));
sigio/sig_in.c:                result = mknode(TYPESIGNATURE, NIL, NIL, NIL, NIL, NIL);
sigio/sig_in.c:                    return(mknode(TSCOMPONENT, id, sig));
sigio/sig_in.c:		    result = mknode(DEFCHARSIGS, 0, 0, 0, 0);
sigio/sig_in.c:		    result = mknode(REXTERNDEF, sig, name);
sigio/sig_in.tmp.icn:#     result = mknode(kindno, string_index);
sigio/sig_in.tmp.icn:#       result = mknode (REXTERNDEF, NIL, NIL);
sigio/sig_in.tmp.icn:# 		    result = mknode(DECLARATION, id, den, sig);
sigio/sig_in.tmp.icn:#                         v = mknode(DECLARATION, NIL, NIL, NIL);
sigio/sig_in.tmp.icn:#                     return(mknode(BLOCKDENOTATION, decl_l, den_s));
sigio/sig_in.tmp.icn:#                     return(mknode(APPLICATION, op, args));
sigio/sig_in.tmp.icn:#                 return(mknode(kindno, list_in(Sinfile)));
sigio/sig_in.tmp.icn:#                     return(mknode(GUARDEDELEMENT, guard, element));
sigio/sig_in.tmp.icn:#                     return(mknode(FUNCCONSTR, sig, body));
sigio/sig_in.tmp.icn:#                     return(mknode(USELIST, type_list, den_seq));
sigio/sig_in.tmp.icn:#                     NODE * result = mknode(MODPRIMARY, NIL, NIL);
sigio/sig_in.tmp.icn:#                     NODE * result = mknode(kindno, NIL, NIL);
sigio/sig_in.tmp.icn:#                 return(mknode(WORDELSE));
sigio/sig_in.tmp.icn:#                     return(mknode(PARAMETER, id, sig));
sigio/sig_in.tmp.icn:# 		    result = mknode(FUNCSIGNATURE,
sigio/sig_in.tmp.icn:#                             v = mknode(PARAMETER, NIL, NIL);
sigio/sig_in.tmp.icn:#                             constr = mknode(FUNCCONSTR,
sigio/sig_in.tmp.icn:# 					    mknode(EXTERNDEF,NIL));
sigio/sig_in.tmp.icn:# 		return(mknode(kindno, sig_in1(Sinfile)));
sigio/sig_in.tmp.icn:# 		return(mknode(SIGNATURESIG));
sigio/sig_in.tmp.icn:#                 result = mknode(TYPESIGNATURE, NIL, NIL, NIL, NIL, NIL);
sigio/sig_in.tmp.icn:#                     return(mknode(TSCOMPONENT, id, sig));
sigio/sig_in.tmp.icn:# 		    result = mknode(DEFCHARSIGS, 0, 0, 0, 0);
sigio/sig_in.tmp.icn:# 		    result = mknode(REXTERNDEF, sig, name);
sigio/sig_in.tmp.icn:# 		    result = mknode(DECLARATION, id, den, sig);
sigio/sig_in.tmp.icn:#                         v = mknode(DECLARATION, NIL, NIL, NIL);
sigio/sig_in.tmp.icn:#                     return(mknode(BLOCKDENOTATION, decl_l, den_s));
sigio/sig_in.tmp.icn:#                     return(mknode(APPLICATION, op, args));
sigio/sig_in.tmp.icn:#                 return(mknode(kindno, list_in(Sinfile)));
sigio/sig_in.tmp.icn:#                     return(mknode(GUARDEDELEMENT, guard, element));
sigio/sig_in.tmp.icn:#                     return(mknode(FUNCCONSTR, sig, body));
sigio/sig_in.tmp.icn:#                     return(mknode(USELIST, type_list, den_seq));
sigio/sig_in.tmp.icn:#                     NODE * result = mknode(MODPRIMARY, NIL, NIL);
sigio/sig_in.tmp.icn:#                     NODE * result = mknode(kindno, NIL, NIL);
sigio/sig_in.tmp.icn:#                 return(mknode(WORDELSE));
sigio/sig_in.tmp.icn:#                     return(mknode(PARAMETER, id, sig));
sigio/sig_in.tmp.icn:# 		    result = mknode(FUNCSIGNATURE,
sigio/sig_in.tmp.icn:#                             v = mknode(PARAMETER, NIL, NIL);
sigio/sig_in.tmp.icn:#                             constr = mknode(FUNCCONSTR,
sigio/sig_in.tmp.icn:# 					    mknode(EXTERNDEF,NIL));
sigio/sig_in.tmp.icn:# 		return(mknode(kindno, sig_in1(Sinfile)));
sigio/sig_in.tmp.icn:# 		return(mknode(SIGNATURESIG));
sigio/sig_in.tmp.icn:#                 result = mknode(TYPESIGNATURE, NIL, NIL, NIL, NIL, NIL);
sigio/sig_in.tmp.icn:#                     return(mknode(TSCOMPONENT, id, sig));
sigio/sig_in.tmp.icn:# 		    result = mknode(DEFCHARSIGS, 0, 0, 0, 0);
sigio/sig_in.tmp.icn:# 		    result = mknode(REXTERNDEF, sig, name);
sigio/sig_in.icn:    result = mknode(kindno, string_index);
sigio/sig_in.icn:      result = mknode (REXTERNDEF, NIL, NIL);
sigio/sig_in.icn:		    result = mknode(DECLARATION, id, den, sig);
sigio/sig_in.icn:                        v = mknode(DECLARATION, NIL, NIL, NIL);
sigio/sig_in.icn:                    return(mknode(BLOCKDENOTATION, decl_l, den_s));
sigio/sig_in.icn:                    return(mknode(APPLICATION, op, args));
sigio/sig_in.icn:                return(mknode(kindno, list_in(Sinfile)));
sigio/sig_in.icn:                    return(mknode(GUARDEDELEMENT, guard, element));
sigio/sig_in.icn:                    return(mknode(FUNCCONSTR, sig, body));
sigio/sig_in.icn:                    return(mknode(USELIST, type_list, den_seq));
sigio/sig_in.icn:                    NODE * result = mknode(MODPRIMARY, NIL, NIL);
sigio/sig_in.icn:                    NODE * result = mknode(kindno, NIL, NIL);
sigio/sig_in.icn:                return(mknode(WORDELSE));
sigio/sig_in.icn:                    return(mknode(PARAMETER, id, sig));
sigio/sig_in.icn:		    result = mknode(FUNCSIGNATURE,
sigio/sig_in.icn:                            v = mknode(PARAMETER, NIL, NIL);
sigio/sig_in.icn:                            constr = mknode(FUNCCONSTR,
sigio/sig_in.icn:					    mknode(EXTERNDEF,NIL));
sigio/sig_in.icn:		return(mknode(kindno, sig_in1(Sinfile)));
sigio/sig_in.icn:		return(mknode(SIGNATURESIG));
sigio/sig_in.icn:                result = mknode(TYPESIGNATURE, NIL, NIL, NIL, NIL, NIL);
sigio/sig_in.icn:                    return(mknode(TSCOMPONENT, id, sig));
sigio/sig_in.icn:		    result = mknode(DEFCHARSIGS, 0, 0, 0, 0);
sigio/sig_in.icn:		    result = mknode(REXTERNDEF, sig, name);
sigio/sig_in.icn:		    result = mknode(DECLARATION, id, den, sig);
sigio/sig_in.icn:                        v = mknode(DECLARATION, NIL, NIL, NIL);
sigio/sig_in.icn:                    return(mknode(BLOCKDENOTATION, decl_l, den_s));
sigio/sig_in.icn:                    return(mknode(APPLICATION, op, args));
sigio/sig_in.icn:                return(mknode(kindno, list_in(Sinfile)));
sigio/sig_in.icn:                    return(mknode(GUARDEDELEMENT, guard, element));
sigio/sig_in.icn:                    return(mknode(FUNCCONSTR, sig, body));
sigio/sig_in.icn:                    return(mknode(USELIST, type_list, den_seq));
sigio/sig_in.icn:                    NODE * result = mknode(MODPRIMARY, NIL, NIL);
sigio/sig_in.icn:                    NODE * result = mknode(kindno, NIL, NIL);
sigio/sig_in.icn:                return(mknode(WORDELSE));
sigio/sig_in.icn:                    return(mknode(PARAMETER, id, sig));
sigio/sig_in.icn:		    result = mknode(FUNCSIGNATURE,
sigio/sig_in.icn:                            v = mknode(PARAMETER, NIL, NIL);
sigio/sig_in.icn:                            constr = mknode(FUNCCONSTR,
sigio/sig_in.icn:					    mknode(EXTERNDEF,NIL));
sigio/sig_in.icn:		return(mknode(kindno, sig_in1(Sinfile)));
sigio/sig_in.icn:		return(mknode(SIGNATURESIG));
sigio/sig_in.icn:                result = mknode(TYPESIGNATURE, NIL, NIL, NIL, NIL, NIL);
sigio/sig_in.icn:                    return(mknode(TSCOMPONENT, id, sig));
sigio/sig_in.icn:		    result = mknode(DEFCHARSIGS, 0, 0, 0, 0);
sigio/sig_in.icn:		    result = mknode(REXTERNDEF, sig, name);
stree/ststructs.m:/* A leading H indicates the field is hidden, and not a parameter to mknode */
stree/ststructs.m:@define emptylist() mknode(LISTHEADER,NIL,NIL)  /* make an empty list */
stree/ststructs.m:void maprlist();                                /* defined in mknode.c */
stree/ststructs.m:NODE * mknode();							  /* defined in mknode.c */
stree/stmkfields.mh: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/listops.c: *   These and the roiutines in mknode.c should be the only routines
stree/listops.c:                case 2: vrtx = mknode(kindno, p, arg1); break;
stree/listops.c:                case 3: vrtx = mknode(kindno, p, arg1, arg2); break;
stree/listops.c:                case 4: vrtx = mknode(kindno, p, arg1, arg2, arg3); break;
stree/listops.c:                case 5: vrtx = mknode(kindno, p, arg1, arg2, arg3, arg4); break;
stree/listops.c:                case 6: vrtx = mknode(kindno, p, arg1, arg2, arg3, arg4, arg5); break;
stree/stsizes.mh: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/stplinks.mh: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/#stplinks.mh#: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/streedefs.h: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/mknode.c:NODE *mknode( va_alist )
stree/mknode.c:            diagmsg("mknode: addr of new node=0%x, kind=%s\n",
stree/mknode.c:    return( (LIST) mknode(LISTHEADER, p, q) );
stree/mknode.c:    result = mknode(LETTERID, sttptr);
stree/stptrs.mh: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/stsigs.mh: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/stformats.h: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/testvertex.c:    p =lock(  mknode(NUMID,1234, NIL)  );
stree/#ststructs.mh#:/* A leading H indicates the field is hidden, and not a parameter to mknode */
stree/#ststructs.mh#: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/#ststructs.mh#:#define emptylist() mknode(LISTHEADER,NIL,NIL)
stree/#ststructs.mh#:/* defined in mknode.c */void maprlist();
stree/#ststructs.mh#:/* defined in mknode.c */NODE * mknode();
stree/st.icn.sav:    ret := mknode([LISTHEADER,nil,nil])
stree/st.icn.sav:		0: vrtx := mknode([kindno])
stree/st.icn.sav:		1: vrtx := mknode([kindno, p])
stree/st.icn.sav:		2: vrtx := mknode([kindno, p, arg1])
stree/st.icn.sav:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/st.icn.sav:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/st.icn.sav:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/st.icn.sav:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/st.icn.sav:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/st.icn.sav:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/st.icn.sav:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/st.icn.sav:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/st.icn.sav:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, ag10 ])
stree/djd:mknode.c:/* tree building routines for declaration tree */
stree/djd:mknode.icn:/* tree building routines for declaration tree */
stree/djd:mknode.icn~:/* tree building routines for declaration tree */
stree/djd:mknode.tmp.icn:# /* tree building routines for declaration tree */
stree/djd:mknode.tmp.icn~:# /* tree building routines for declaration tree */
stree/ststructs_cls.tmp.icn:    ret := mknode([LISTHEADER,nil,nil])
stree/ststructs_cls.tmp.icn:		0: vrtx := mknode([kindno])
stree/ststructs_cls.tmp.icn:		1: vrtx := mknode([kindno, p])
stree/ststructs_cls.tmp.icn:		2: vrtx := mknode([kindno, p, arg1])
stree/ststructs_cls.tmp.icn:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/ststructs_cls.tmp.icn:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/ststructs_cls.tmp.icn:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/ststructs_cls.tmp.icn:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/ststructs_cls.tmp.icn:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/ststructs_cls.tmp.icn:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/ststructs_cls.tmp.icn:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/ststructs_cls.tmp.icn:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/ststructs_cls.tmp.icn:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, arg10 ])
stree/stplinks.sav01.icn: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/st.icn.sav3:    ret := mknode([LISTHEADER,nil,nil])
stree/st.icn.sav3:		0: vrtx := mknode([kindno])
stree/st.icn.sav3:		1: vrtx := mknode([kindno, p])
stree/st.icn.sav3:		2: vrtx := mknode([kindno, p, arg1])
stree/st.icn.sav3:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/st.icn.sav3:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/st.icn.sav3:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/st.icn.sav3:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/st.icn.sav3:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/st.icn.sav3:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/st.icn.sav3:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/st.icn.sav3:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/st.icn.sav3:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, ag10 ])
stree/st.icn.sav4:    ret := mknode([LISTHEADER,nil,nil])
stree/st.icn.sav4:		0: vrtx := mknode([kindno])
stree/st.icn.sav4:		1: vrtx := mknode([kindno, p])
stree/st.icn.sav4:		2: vrtx := mknode([kindno, p, arg1])
stree/st.icn.sav4:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/st.icn.sav4:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/st.icn.sav4:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/st.icn.sav4:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/st.icn.sav4:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/st.icn.sav4:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/st.icn.sav4:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/st.icn.sav4:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/st.icn.sav4:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, ag10 ])
stree/st.icn.sav2:    ret := mknode([LISTHEADER,nil,nil])
stree/st.icn.sav2:		0: vrtx := mknode([kindno])
stree/st.icn.sav2:		1: vrtx := mknode([kindno, p])
stree/st.icn.sav2:		2: vrtx := mknode([kindno, p, arg1])
stree/st.icn.sav2:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/st.icn.sav2:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/st.icn.sav2:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/st.icn.sav2:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/st.icn.sav2:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/st.icn.sav2:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/st.icn.sav2:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/st.icn.sav2:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/st.icn.sav2:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, ag10 ])
stree/ststructs.mh:/* A leading H indicates the field is hidden, and not a parameter to mknode */
stree/ststructs.mh: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/ststructs.mh:#define emptylist() mknode(LISTHEADER,NIL,NIL)
stree/ststructs.mh:/* defined in mknode.c */void maprlist();
stree/ststructs.mh:/* defined in mknode.c */NODE * mknode();
stree/st.icn.wrk:    ret := mknode([LISTHEADER,nil,nil])
stree/st.icn.wrk:		0: vrtx := mknode([kindno])
stree/st.icn.wrk:		1: vrtx := mknode([kindno, p])
stree/st.icn.wrk:		2: vrtx := mknode([kindno, p, arg1])
stree/st.icn.wrk:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/st.icn.wrk:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/st.icn.wrk:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/st.icn.wrk:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/st.icn.wrk:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/st.icn.wrk:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/st.icn.wrk:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/st.icn.wrk:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/st.icn.wrk:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, ag10 ])
stree/stplinks.icn: *      i.e. not passed to mknode ), SIG, and HSIG.
stree/mknode.tmp.icn:#	File:     mknode.icn
stree/mknode.tmp.icn:# NODE *mknode( va_alist )
stree/mknode.tmp.icn:#             diagmsg("mknode: addr of new node=0%x, kind=%s\n",
stree/mknode.tmp.icn:#     return( (LIST) mknode(LISTHEADER, p, q) );
stree/mknode.tmp.icn:#     result = mknode(LETTERID, sttptr);
stree/mknode.tmp.icn:# NODE *mknode( va_alist )
stree/mknode.tmp.icn:#             diagmsg("mknode: addr of new node=0%x, kind=%s\n",
stree/mknode.tmp.icn:procedure mknode(va_alist)
stree/mknode.tmp.icn:    yyinfo("mknode va_alist")
stree/mknode.tmp.icn:	    default: rpt_err("mknode no of args not implemented")
stree/mknode.tmp.icn:	default: rpt_err("mknode not implemented dump_info(arg1) = " || dump_info(arg1))
stree/mknode.tmp.icn:    result := mknode([LETTERID, sttptr])
stree/st.wrk.out:    ret := mknode([LISTHEADER,nil,nil])
stree/st.wrk.out:		0: vrtx := mknode([kindno])
stree/st.wrk.out:		1: vrtx := mknode([kindno, p])
stree/st.wrk.out:		2: vrtx := mknode([kindno, p, arg1])
stree/st.wrk.out:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/st.wrk.out:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/st.wrk.out:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/st.wrk.out:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/st.wrk.out:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/st.wrk.out:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/st.wrk.out:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/st.wrk.out:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/st.wrk.out:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, ag10 ])
stree/ststructs_cls.icn~:    ret := mknode([LISTHEADER,nil,nil])
stree/ststructs_cls.icn~:		0: vrtx := mknode([kindno])
stree/ststructs_cls.icn~:		1: vrtx := mknode([kindno, p])
stree/ststructs_cls.icn~:		2: vrtx := mknode([kindno, p, arg1])
stree/ststructs_cls.icn~:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/ststructs_cls.icn~:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/ststructs_cls.icn~:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/ststructs_cls.icn~:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/ststructs_cls.icn~:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/ststructs_cls.icn~:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/ststructs_cls.icn~:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/ststructs_cls.icn~:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/ststructs_cls.icn~:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, arg10 ])
stree/mknode.icn~:#	File:     mknode.icn
stree/mknode.icn~:NODE *mknode( va_alist )
stree/mknode.icn~:            diagmsg("mknode: addr of new node=0%x, kind=%s\n",
stree/mknode.icn~:    return( (LIST) mknode(LISTHEADER, p, q) );
stree/mknode.icn~:    result = mknode(LETTERID, sttptr);
stree/mknode.icn~:NODE *mknode( va_alist )
stree/mknode.icn~:            diagmsg("mknode: addr of new node=0%x, kind=%s\n",
stree/mknode.icn~:procedure mknode(va_alist)
stree/mknode.icn~:    yyinfo("mknode va_alist")
stree/mknode.icn~:	    default: rpt_err("mknode no of args not implemented")
stree/mknode.icn~:	default: rpt_err("mknode not implemented dump_info(arg1) = " || dump_info(arg1))
stree/mknode.icn~:    result := mknode([LETTERID, sttptr])
stree/mknode.icn:#	File:     mknode.icn
stree/mknode.icn:NODE *mknode( va_alist )
stree/mknode.icn:            diagmsg("mknode: addr of new node=0%x, kind=%s\n",
stree/mknode.icn:    return( (LIST) mknode(LISTHEADER, p, q) );
stree/mknode.icn:    result = mknode(LETTERID, sttptr);
stree/mknode.icn:NODE *mknode( va_alist )
stree/mknode.icn:            diagmsg("mknode: addr of new node=0%x, kind=%s\n",
stree/mknode.icn:procedure mknode(va_alist)
stree/mknode.icn:    yyinfo("mknode va_alist")
stree/mknode.icn:	    default: rpt_err("mknode no of args not implemented")
stree/mknode.icn:	default: rpt_err("mknode not implemented dump_info(arg1) = " || dump_info(arg1))
stree/mknode.icn:    result := mknode([LETTERID, sttptr])
stree/ststructs_cls.icn:    ret := mknode([LISTHEADER,nil,nil])
stree/ststructs_cls.icn:		0: vrtx := mknode([kindno])
stree/ststructs_cls.icn:		1: vrtx := mknode([kindno, p])
stree/ststructs_cls.icn:		2: vrtx := mknode([kindno, p, arg1])
stree/ststructs_cls.icn:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/ststructs_cls.icn:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/ststructs_cls.icn:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/ststructs_cls.icn:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/ststructs_cls.icn:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/ststructs_cls.icn:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/ststructs_cls.icn:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/ststructs_cls.icn:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/ststructs_cls.icn:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, arg10 ])
stree/#ststructs_cls.icn#:    ret := mknode([LISTHEADER,nil,nil])
stree/#ststructs_cls.icn#:		0: vrtx := mknode([kindno])
stree/#ststructs_cls.icn#:		1: vrtx := mknode([kindno, p])
stree/#ststructs_cls.icn#:		2: vrtx := mknode([kindno, p, arg1])
stree/#ststructs_cls.icn#:                3: vrtx := mknode([ kindno, p ,arg1, arg2])
stree/#ststructs_cls.icn#:		4: vrtx := mknode([kindno, p, arg1, arg2, arg3])
stree/#ststructs_cls.icn#:		5: vrtx := mknode([kindno,p, arg1, arg2, arg3, arg4])
stree/#ststructs_cls.icn#:                6: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5 ])
stree/#ststructs_cls.icn#:                7: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6 ])
stree/#ststructs_cls.icn#:                8: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6,arg7 ])
stree/#ststructs_cls.icn#:                9: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7. arg8 ])
stree/#ststructs_cls.icn#:                10: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ])
stree/#ststructs_cls.icn#:                11: vrtx := mknode([ kindno, p,arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg7, arg9, arg10 ])
ststructs_cls.tmp.u:	local	3,000000,mknode
ststructs_cls.tmp.u:	local	21,000000,mknode
Binary file tmain matches
tmain.icn:    id_Boolean := mknode([LETTERID, indx_Boolean])
tmain.icn:    id_Void := mknode([LETTERID, indx_Void])
tmain.icn:    id_Integer := mknode([LETTERID, indx_Integer])
tmain.icn:    id_put := mknode([LETTERID, indx_put])
tmain.icn:    id_ValueOf := mknode([LETTERID, indx_ValueOf])
tmain.icn:    id_New := mknode([LETTERID, indx_New])
tmain.icn:    id_size := mknode([LETTERID, indx_size])
tmain.icn:    id_Null := mknode([LETTERID, indx_Null])
tmain.icn:    id_times := mknode([LETTERID, indx_times])
tmain.icn:    id_plus := mknode([LETTERID, indx_plus])
tmain.icn~:    id_Boolean := mknode([LETTERID, indx_Boolean])
tmain.icn~:    id_Void := mknode([LETTERID, indx_Void])
tmain.icn~:    id_Integer := mknode([LETTERID, indx_Integer])
tmain.icn~:    id_put := mknode([LETTERID, indx_put])
tmain.icn~:    id_ValueOf := mknode([LETTERID, indx_ValueOf])
tmain.icn~:    id_New := mknode([LETTERID, indx_New])
tmain.icn~:    id_size := mknode([LETTERID, indx_size])
tmain.icn~:    id_Null := mknode([LETTERID, indx_Null])
tmain.icn~:    id_times := mknode([LETTERID, indx_times])
tmain.icn~:    id_plus := mknode([LETTERID, indx_plus])
tmain.tmp.icn:    id_Boolean := mknode([LETTERID, indx_Boolean])
tmain.tmp.icn:    id_Void := mknode([LETTERID, indx_Void])
tmain.tmp.icn:    id_Integer := mknode([LETTERID, indx_Integer])
tmain.tmp.icn:    id_put := mknode([LETTERID, indx_put])
tmain.tmp.icn:    id_ValueOf := mknode([LETTERID, indx_ValueOf])
tmain.tmp.icn:    id_New := mknode([LETTERID, indx_New])
tmain.tmp.icn:    id_size := mknode([LETTERID, indx_size])
tmain.tmp.icn:    id_Null := mknode([LETTERID, indx_Null])
tmain.tmp.icn:    id_times := mknode([LETTERID, indx_times])
tmain.tmp.icn:    id_plus := mknode([LETTERID, indx_plus])
tsig_order.tmp.u:	local	16,000000,mknode
urusserr.tmp:itids.tmp.icn:  116  | | mknode(list_108 = [32,36])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_109 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_1(&null,&null,0,9999,&null,&null,2,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_1(36,&null,&null,&null,object ListHeaderNode_1(11),&null,&null,&null,&null,&null,32,9999,&null,&null,1,&null,&null)
urusserr.tmp:itids.tmp.icn:  117  | | mknode(list_110 = [32,40])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_111 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_2(&null,&null,0,9999,&null,&null,4,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_2(40,&null,&null,&null,object ListHeaderNode_2(11),&null,&null,&null,&null,&null,32,9999,&null,&null,3,&null,&null)
urusserr.tmp:itids.tmp.icn:  118  | | mknode(list_112 = [32,39])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_113 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_3(&null,&null,0,9999,&null,&null,6,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_3(39,&null,&null,&null,object ListHeaderNode_3(11),&null,&null,&null,&null,&null,32,9999,&null,&null,5,&null,&null)
urusserr.tmp:itids.tmp.icn:  119  | | mknode(list_114 = [32,42])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_115 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_4(&null,&null,0,9999,&null,&null,8,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_4(42,&null,&null,&null,object ListHeaderNode_4(11),&null,&null,&null,&null,&null,32,9999,&null,&null,7,&null,&null)
urusserr.tmp:itids.tmp.icn:  120  | | mknode(list_116 = [32,26])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_117 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_5(&null,&null,0,9999,&null,&null,10,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_5(26,&null,&null,&null,object ListHeaderNode_5(11),&null,&null,&null,&null,&null,32,9999,&null,&null,9,&null,&null)
urusserr.tmp:itids.tmp.icn:  121  | | mknode(list_118 = [32,23])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_119 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_6(&null,&null,0,9999,&null,&null,12,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_6(23,&null,&null,&null,object ListHeaderNode_6(11),&null,&null,&null,&null,&null,32,9999,&null,&null,11,&null,&null)
urusserr.tmp:itids.tmp.icn:  122  | | mknode(list_120 = [32,44])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_121 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_7(&null,&null,0,9999,&null,&null,14,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_7(44,&null,&null,&null,object ListHeaderNode_7(11),&null,&null,&null,&null,&null,32,9999,&null,&null,13,&null,&null)
urusserr.tmp:itids.tmp.icn:  123  | | mknode(list_122 = [32,50])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_123 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_8(&null,&null,0,9999,&null,&null,16,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_8(50,&null,&null,&null,object ListHeaderNode_8(11),&null,&null,&null,&null,&null,32,9999,&null,&null,15,&null,&null)
urusserr.tmp:itids.tmp.icn:  124  | | mknode(list_124 = [32,15])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_125 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_9(&null,&null,0,9999,&null,&null,18,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_9(15,&null,&null,&null,object ListHeaderNode_9(11),&null,&null,&null,&null,&null,32,9999,&null,&null,17,&null,&null)
urusserr.tmp:itids.tmp.icn:  125  | | mknode(list_126 = [32,13])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_127 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_10(&null,&null,0,9999,&null,&null,20,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_10(13,&null,&null,&null,object ListHeaderNode_10(11),&null,&null,&null,&null,&null,32,9999,&null,&null,19,&null,&null)
urusserr.tmp:itids.tmp.icn:  130  | | mknode(list_128 = [5,object LetterId_1(19)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ValSignature_1(object LetterId_1(19),&null,&null,5,9999,&null,&null,21,&null,&null)
urusserr.tmp:itids.tmp.icn:  133  | | mknode(list_129 = [5,object LetterId_3(19)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ValSignature_2(object LetterId_3(19),&null,&null,5,9999,&null,&null,22,&null,&null)
urusserr.tmp:itids.tmp.icn:  136  | | mknode(list_130 = [5,object LetterId_2(19)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ValSignature_3(object LetterId_2(19),&null,&null,5,9999,&null,&null,23,&null,&null)
urusserr.tmp:itids.tmp.icn:  139  | | mknode(list_131 = [4,object LetterId_2(19)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object VarSignature_1(object LetterId_2(19),&null,&null,4,9999,&null,&null,24,&null,&null)
urusserr.tmp:itids.tmp.icn:  145  | | mknode(list_132 = [32])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_133 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_11(&null,&null,0,9999,&null,&null,26,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_11(&null,&null,&null,&null,object ListHeaderNode_11(11),&null,&null,&null,&null,&null,32,9999,&null,&null,25,&null,&null)
urusserr.tmp:itids.tmp.icn:  143  | | mknode(list_134 = [5,object LetterId_11(19)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ValSignature_4(object LetterId_11(19),&null,&null,5,9999,&null,&null,27,&null,&null)
urusserr.tmp:itids.tmp.icn:  143  | | mknode(list_135 = [2,&null,object ValSignature_4(12)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ParameterNode_1(&null,object ValSignature_4(12),&null,&null,&null,&null,&null,2,9999,&null,&null,28,&null,&null)
urusserr.tmp:itids.tmp.icn:  152  | | mknode(list_136 = [32])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_137 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_12(&null,&null,0,9999,&null,&null,30,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_12(&null,&null,&null,&null,object ListHeaderNode_12(11),&null,&null,&null,&null,&null,32,9999,&null,&null,29,&null,&null)
urusserr.tmp:itids.tmp.icn:  150  | | mknode(list_138 = [4,object LetterId_12(19)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object VarSignature_2(object LetterId_12(19),&null,&null,4,9999,&null,&null,31,&null,&null)
urusserr.tmp:itids.tmp.icn:  150  | | mknode(list_139 = [2,0,object VarSignature_2(12)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ParameterNode_2(0,object VarSignature_2(12),&null,&null,&null,&null,&null,2,9999,&null,&null,32,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | mknode(list_141 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | mknode returned object ListHeaderNode_13(&null,&null,0,9999,&null,&null,33,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | mknode(list_143 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | mknode returned object ListHeaderNode_14(&null,&null,0,9999,&null,&null,36,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | mknode(list_145 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | mknode returned object ListHeaderNode_15(&null,&null,0,9999,&null,&null,39,&null,&null)
urusserr.tmp:itids.tmp.icn:  161  | | mknode(list_146 = [6,&null,object ListHeaderNode_13(11),object ValSignature_4(12)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_147 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_16(&null,&null,0,9999,&null,&null,43,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object FSignature_1(&null,object ListHeaderNode_13(11),object ValSignature_4(12),&null,&null,&null,object ListHeaderNode_16(11),&null,&null,6,9999,&null,&null,42,&null,&null)
urusserr.tmp:itids.tmp.icn:  166  | | mknode(list_148 = [6,&null,object ListHeaderNode_14(11),object ValSignature_4(12)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_149 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_17(&null,&null,0,9999,&null,&null,45,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object FSignature_2(&null,object ListHeaderNode_14(11),object ValSignature_4(12),&null,&null,&null,object ListHeaderNode_17(11),&null,&null,6,9999,&null,&null,44,&null,&null)
urusserr.tmp:itids.tmp.icn:  172  | | mknode(list_150 = [6,&null,object ListHeaderNode_14(11),object ValSignature_1(12)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_151 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_18(&null,&null,0,9999,&null,&null,47,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object FSignature_3(&null,object ListHeaderNode_14(11),object ValSignature_1(12),&null,&null,&null,object ListHeaderNode_18(11),&null,&null,6,9999,&null,&null,46,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | mknode(list_152 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object ListHeaderNode_19(&null,&null,0,9999,&null,&null,48,&null,&null)
urusserr.tmp:itids.tmp.icn:  173  | | mknode(list_153 = [6,&null,object ListHeaderNode_19(11),object VarSignature_2(12)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_154 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_20(&null,&null,0,9999,&null,&null,50,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object FSignature_4(&null,object ListHeaderNode_19(11),object VarSignature_2(12),&null,&null,&null,object ListHeaderNode_20(11),&null,&null,6,9999,&null,&null,49,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | mknode(list_155 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object ListHeaderNode_21(&null,&null,0,9999,&null,&null,51,&null,&null)
urusserr.tmp:itids.tmp.icn:  175  | | mknode(list_156 = [6,&null,object ListHeaderNode_21(11),object ValSignature_4(12)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_157 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_22(&null,&null,0,9999,&null,&null,53,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object FSignature_5(&null,object ListHeaderNode_21(11),object ValSignature_4(12),&null,&null,&null,object ListHeaderNode_22(11),&null,&null,6,9999,&null,&null,52,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | mknode(list_159 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | mknode returned object ListHeaderNode_23(&null,&null,0,9999,&null,&null,54,&null,&null)
urusserr.tmp:itids.tmp.icn:  177  | | mknode(list_160 = [6,&null,object ListHeaderNode_23(11),object ValSignature_4(12)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_161 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_24(&null,&null,0,9999,&null,&null,57,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object FSignature_6(&null,object ListHeaderNode_23(11),object ValSignature_4(12),&null,&null,&null,object ListHeaderNode_24(11),&null,&null,6,9999,&null,&null,56,&null,&null)
urusserr.tmp:itids.tmp.icn:  180  | | mknode(list_162 = [10])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object SignatureSigNode_1(&null,&null,10,9999,&null,&null,58,&null,&null)
urusserr.tmp:itids.tmp.icn:  182  | | mknode(list_163 = [32,37])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_164 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_25(&null,&null,0,9999,&null,&null,60,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_13(37,&null,&null,&null,object ListHeaderNode_25(11),&null,&null,&null,&null,&null,32,9999,&null,&null,59,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | mknode(list_165 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object ListHeaderNode_26(&null,&null,0,9999,&null,&null,61,&null,&null)
urusserr.tmp:itids.tmp.icn:  184  | | mknode(list_166 = [13,object LetterId_13(19),object ListHeaderNode_26(11)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_167 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_27(&null,&null,0,9999,&null,&null,63,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ApplicationNode_1(object LetterId_13(19),object ListHeaderNode_26(11),&null,object ListHeaderNode_27(11),&null,13,9999,&null,&null,62,&null,&null)
urusserr.tmp:itids.tmp.icn:  187  | | mknode(list_168 = [32,38])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_169 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_28(&null,&null,0,9999,&null,&null,65,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object LetterId_14(38,&null,&null,&null,object ListHeaderNode_28(11),&null,&null,&null,&null,&null,32,9999,&null,&null,64,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | mknode(list_170 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object ListHeaderNode_29(&null,&null,0,9999,&null,&null,66,&null,&null)
urusserr.tmp:itids.tmp.icn:  189  | | mknode(list_171 = [13,object LetterId_14(19),object ListHeaderNode_29(11)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_172 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_30(&null,&null,0,9999,&null,&null,68,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ApplicationNode_2(object LetterId_14(19),object ListHeaderNode_29(11),&null,object ListHeaderNode_30(11),&null,13,9999,&null,&null,67,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | mknode(list_173 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object ListHeaderNode_31(&null,&null,0,9999,&null,&null,69,&null,&null)
urusserr.tmp:itids.tmp.icn:  192  | | mknode(list_174 = [13,object LetterId_8(19),object ListHeaderNode_31(11)])
urusserr.tmp:knode.tmp.icn:  460  | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | mknode(list_175 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | mknode returned object ListHeaderNode_32(&null,&null,0,9999,&null,&null,71,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | mknode returned object ApplicationNode_3(object LetterId_8(19),object ListHeaderNode_31(11),&null,object ListHeaderNode_32(11),&null,13,9999,&null,&null,70,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | mknode(list_193 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | mknode returned object ListHeaderNode_33(&null,&null,0,1,&null,&null,72,&null,&null)
urusserr.tmp:fixed.tmp.icn:  518  | | | mknode(list_194 = [11,object ListHeaderNode_33(11),&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | | mknode(list_195 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | | mknode returned object ListHeaderNode_34(&null,&null,0,1,&null,&null,74,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | | mknode(list_196 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | | mknode returned object ListHeaderNode_35(&null,&null,0,1,&null,&null,75,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object BlDenotationNode_1(object ListHeaderNode_33(11),&null,&null,&null,&null,object ListHeaderNode_34(11),object ListHeaderNode_35(11),&null,0,&null,11,1,&null,&null,73,&null,&null)
urusserr.tmp:fixed.tmp.icn: 1146  | | | mknode(list_204 = [31,53])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | | mknode(list_205 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | | mknode returned object ListHeaderNode_36(&null,&null,0,2,&null,&null,77,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object OpridNode_1(53,&null,&null,&null,object ListHeaderNode_36(11),&null,&null,&null,&null,&null,31,2,&null,&null,76,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | mknode(list_207 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | mknode returned object ListHeaderNode_37(&null,&null,0,2,&null,&null,78,&null,&null)
urusserr.tmp:fixed.tmp.icn: 1144  | | | mknode(list_210 = [32,54])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | | mknode(list_211 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | | mknode returned object ListHeaderNode_38(&null,&null,0,2,&null,&null,81,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object LetterId_15(54,&null,&null,&null,object ListHeaderNode_38(11),&null,&null,&null,&null,&null,32,2,&null,&null,80,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | mknode(list_213 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | mknode returned object ListHeaderNode_39(&null,&null,0,2,&null,&null,82,&null,&null)
urusserr.tmp:fixed.tmp.icn: 1144  | | | mknode(list_214 = [32,39])
urusserr.tmp:knode.tmp.icn:  460  | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | | mknode(list_215 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | | mknode returned object ListHeaderNode_40(&null,&null,0,2,&null,&null,85,&null,&null)
urusserr.tmp:knode.tmp.icn:  540  | | | mknode returned object LetterId_16(39,&null,&null,&null,object ListHeaderNode_40(11),&null,&null,&null,&null,&null,32,2,&null,&null,84,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | mknode(list_217 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | mknode returned object ListHeaderNode_41(&null,&null,0,2,&null,&null,86,&null,&null)
urusserr.tmp:s_cls.tmp.icn:  108  | | | | | | | mknode(list_220 = [0,&null,&null])
urusserr.tmp:knode.tmp.icn:  460  | | | | | | | | yyinfo("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  195  | | | | | | | | | rpt_info("mknode va_alist")
urusserr.tmp:mine.tmp.icn :  117  | | | | | | | | | | rpt_it("mknode va_alist",2)
urusserr.tmp:INFO: mknode va_alist
urusserr.tmp:knode.tmp.icn:  540  | | | | | | | mknode returned object ListHeaderNode_42(&null,&null,0,2,&null,&null,88,&null,&null)
urusserr.tmp:   mknode = procedure mknode
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
#urussout.tmp#:INFO: mknode va_alist
Vax_Makefile:stree/stree.o:  stree/mknode.o stree/listops.o stree/prstree.o stree/drefops.o stree/kindname.o stree/bitcnt.o stree/unparse.o
Vax_Makefile:	-ld -r -o stree/stree.o  stree/mknode.o stree/listops.o stree/prstree.o stree/drefops.o stree/kindname.o stree/bitcnt.o stree/unparse.o
Vax_Makefile:stree/mknode.o: $(stinclfiles)
