void STRSGLR_ensure_init(void)
{
ATerm foo;
static ATbool STRSGLR_init = ATfalse;
if(STRSGLR_init)
return;
STRSGLR_init = ATtrue;
ATregisterBlobDestructor(parse_table_blob_destructor);
PT_initMEPTApi();
PT_initAsFix2Api();
initErrorApi();
SG_TOOLBUS_OFF();
SG_OUTPUT_ON();
foo = STRSGLR_set_default_config();
none_term = (ATerm) ATmakeAppl(ATmakeAFun("None", 0, ATfalse));
active_parse_tables = ATmakeList(0);
inactive_parse_tables = malloc(sizeof(ATerm*) * MAX_INACTIVE_PARSE_TABLES);
num_inactive_parse_tables = 0;
ATprotect(&none_term);
ATprotect(&parse_error_term);
ATprotectList(&active_parse_tables);
}
static void init_module_constant_terms (void)
{
ATprotect(&(term0));
term0 = (ATerm) ATmakeAppl(ATmakeSymbol("kaas", 0, ATtrue));
ATprotect(&(term1));
term1 = term0;
}
void ACC_init_throws() {
data_stack = ATempty;
unfold_stack = ATempty;
ATprotect((ATerm*)&data_stack);
ATprotect((ATerm*)&unfold_stack);
thrown = -1;
}
int main(int argc, char *argv[])
{
ATerm tree;
ATinit(argc, argv, &tree);
ATprotect((ATerm*)&imported);
ATprotect(&parse_tree);
ATprotect((ATerm*)&includes);
process_options(argc, argv);
imported = ATmakeList0();
yydebug = 0;
open_dependencies(input_file);
tree = parse_file(input_file);
/* Open output file */
if (output_file == NULL)
outfile = stdout;
else
outfile = fopen(output_file, "w");
if(binary_output)
ATwriteToBinaryFile(tree, outfile);
else
ATwriteToTextFile(tree, outfile);
/* print_dependencies(input_file, imported); */
exit(0);
}
static void init_module_constant_terms(void)
{
ATfprintf(stderr, "init_constant_terms (bar.c)()\n");
ATprotect(&(term_p_0));
term_p_0 = (ATerm) ATmakeAppl(ATmakeSymbol("a", 0, ATtrue));
ATfprintf(stderr, "init_constant_terms (bar.c) end()\n");
}
int HFinit(HFtree *tree, HTable *terms){
/* Protect and assign constants */
ESCAPE_SEQUENCE=ATmake("<str(<appl>)>","ESC","NEW");
NO_ATERM =ATmake("<str(<appl>)>","ESC","NIL");
ATprotect(&ESCAPE_SEQUENCE);
ATprotect(&NO_ATERM);
/* Init LZ buffer */
LZinit(&tree->buffer);
/* Assign terms table */
tree->terms=terms;
/* Create the root node */
tree->codes=(struct HFnode*)malloc(sizeof(struct HFnode));
tree->codes->high=NULL;
tree->codes->parent=NULL;
tree->codes->frequency=0L;
tree->codes->term=NULL;
/* Create the leaf for the escape code */
tree->codes->low=(struct HFnode*)malloc(sizeof(struct HFnode));
tree->codes->low->high=NULL;
tree->codes->low->low=NULL;
tree->codes->low->parent=tree->codes;
tree->codes->low->frequency=0L;
tree->codes->low->term=ESCAPE_SEQUENCE;
/* Store the escape sequence term */
tree->top=tree->codes->low;
/* Initialise the block list */
BLinit(&tree->blockList);
BLinsert(&tree->blockList, tree->codes->low);
BLinsert(&tree->blockList, tree->codes);
return 1;
}
static PT_Tree noAnno()
{
static PTPT_ATerm trm = NULL;
if (trm == NULL) {
trm = PTPT_liftATerm(ATparse("annotation-unavailable"));
ATprotect((ATerm*) ((void*) &trm));
}
return (PT_Tree) trm;
}
PT_Tree PT_findTreeParent(PT_Tree needle, PT_Tree haystack)
{
PT_Tree result;
if (findParentCache == NULL) {
findParentCache = ATtableCreate(1024, 75);
NeedleNotHere = ATparse("needle-not-here");
ATprotect(&NeedleNotHere);
}
result = PT_findTreeParentRecursive(needle, haystack);
ATtableReset(findParentCache);
return result;
}
void init_acdata_dict()
{
ATermList afuns, terms;
_acdata_dict = (ATermList)ATreadFromBinaryString(_acdata_dict_baf, _acdata_dict_LEN);
ATprotect((ATerm *)&_acdata_dict);
afuns = (ATermList)ATelementAt(_acdata_dict, 0);
terms = (ATermList)ATelementAt(_acdata_dict, 1);
}
void register_prod(ATerm prod, funcptr func, Symbol sym)
{
unsigned int hnr; /* hash number */
bucket *b; /* single bucket */
/* Heuristics for deciding when to rehash */
if((nr_entries*100)/table_size > MAX_LOAD) {
c_rehash(table_size*2);
}
#ifdef NO_SHARING
/* calc_hash is recursive, so no mod included */
hnr = calc_hash(prod);
hnr %= table_size;
#else
hnr = HASH_PROD(prod, table_size);
#endif
/* Find out if this function has already been registered */
b = prod_table[hnr];
while(b && !ATisEqual(b->prod, prod))
b = b->next_prod;
/* if already registered, we are done */
if(b)
return;
/* Else we should add a new bucket */
b = malloc(sizeof(bucket));
if(!b)
ATabort("out of memory in register.\n");
b->next_prod = prod_table[hnr];
prod_table[hnr] = b;
/* Add it to the sym table also. */
hnr = HASH_SYM(sym, table_size);
b->next_sym = sym_table[hnr];
sym_table[hnr] = b;
/* The prod field of the bucket is protected against
* the gc.
*/
b->prod = prod;
ATprotect((ATerm*)&(b->prod));
b->func = func;
b->sym = sym;
}
void initAbsInt(){
ATbool ok;
AFun memberTag;
initTables();
conflictingPars = ATmakeList0();
ATprotect((ATerm *)&conflictingPars);
memberTag = createNewFuncSym(memberSym,
ATmakeList2(MCRLterm_bool, liftSort(MCRLterm_bool)));
MCRLputMap((ATerm)ATmakeAppl2(memberTag,
MCRLterm_bool, liftSort(MCRLterm_bool)),
MCRLterm_bool, &ok);
}
void init_terms_dict()
{
ATermList afuns, terms;
_terms_dict = ATreadFromBinaryString(_terms_dict_baf, _terms_dict_LEN);
ATprotect(&_terms_dict);
afuns = (ATermList)ATelementAt((ATermList)_terms_dict, 0);
terms = (ATermList)ATelementAt((ATermList)_terms_dict, 1);
AnnotatedTrueAndFalse = ATgetFirst(terms);
terms = ATgetNext(terms);
DeclareA = ATgetFirst(terms);
terms = ATgetNext(terms);
DeclareAB = ATgetFirst(terms);
terms = ATgetNext(terms);
DeclareB = ATgetFirst(terms);
terms = ATgetNext(terms);
False = ATgetFirst(terms);
terms = ATgetNext(terms);
OtherTrueAndFalse = ATgetFirst(terms);
terms = ATgetNext(terms);
Ten = ATgetFirst(terms);
terms = ATgetNext(terms);
True = ATgetFirst(terms);
terms = ATgetNext(terms);
TrueAndFalse = ATgetFirst(terms);
terms = ATgetNext(terms);
Twenty = ATgetFirst(terms);
terms = ATgetNext(terms);
Two = ATgetFirst(terms);
terms = ATgetNext(terms);
dummy = ATgetFirst(terms);
terms = ATgetNext(terms);
}
ACB new_acb(ACData agent, ACData action) {
ACCACB acb = (ACCACB)malloc(sizeof(struct accacb));
INIT_EXCEPTION_STACK(acb->exception_stack);
INIT_DATA_STACK(acb->result);
INIT_DATA_STACK(acb->data);
acb->data = ATmakeList0();
acb->scope = ATmakeList0();
acb->saved_data = ATmakeList0();
acb->saved_scope = ATmakeList0();
ATprotect(&(acb->result));
ATprotect(&(acb->data));
ATprotect(&(acb->scope));
ATprotect(&(acb->saved_data));
ATprotect(&(acb->saved_scope));
acb->tagged_buffer = ATtableCreate(100, 80);
acb->agent = agent;
acb->action = action;
ATprotect(&(acb->agent));
ATprotect(&(acb->action));
acb->return_stack.top = NULL;
acb->exit_status = NORMAL_OUTCOME;
acb->prev = NULL;
return acb;
}
void init_SetAndElem ( ) {
ATprotect ( & constant0 ) ;
ATprotect ( & constant1 ) ;
}
int main(int argc, char *argv[]) {
int i, j = 0;
char **newargv = (char**) calloc(argc + 2, sizeof(char*));
ATsetWarningHandler(WarningHandler);
ATsetErrorHandler(ErrorHandler);
if (!newargv) ATerror("Cannot allocate array argv");
newargv[j++] = argv[0]; newargv[j++] = "-no-extra-rules";
ATinit(argc, argv, (ATerm*) &argc);
ATprotect((ATerm*) &smds);
ATprotect((ATerm*) &pars);
ATprotect((ATerm*) &inits);
ATprotect((ATerm*) &vars);
ATprotect((ATerm*) &actnames);
ATprotect((ATerm*) &actargs);
vars = actnames = actargs = ATempty;
for (i=1;i<argc;i++) {
if (!strcmp(argv[i],"-help")) {
help();
exit(0);
}
if (!strcmp(argv[i],"-version")) {
version();
exit(0);
}
if (!strcmp(argv[i],"-pars")) {
pars = ATempty;
continue;
}
if (!strcmp(argv[i],"-npars")) {
npars = ATtrue;
continue;
}
if (!strcmp(argv[i],"-extra")) {
extra = ATtrue;
continue;
}
newargv[j++] = argv[i];
}
if (extra) {
if (!MCRLinitRW(j, newargv)) exit(EXIT_FAILURE);
RWdeclareVariables(MCRLgetListOfPars());
}
else
{if (!MCRLinitSU(j, newargv)) exit(EXIT_FAILURE);}
if (npars) {
fprintf(stdout,"%d", MCRLgetNumberOfPars());
exit(EXIT_SUCCESS);
}
smds = MCRLgetListOfSummands();
if (pars) {
pars = MCRLgetListOfPars();
inits = MCRLgetListOfInitValues();
}
ATfprintf(stdout, "Number of process parameters: %d\n",
MCRLgetNumberOfPars());
ATfprintf(stdout, "Number of summands: %d\n",ATgetLength(smds));
for (;!ATisEmpty(smds);smds=ATgetNext(smds)) {
ATerm smd = ATgetFirst(smds);
ATerm actname = ATgetArgument((ATermAppl) smd, 1),
actarg = ATgetArgument((ATermAppl) smd, 2);
vars = ATconcat(vars, (ATermList) ATgetArgument((ATermAppl) smd, 0));
if (ATindexOf(actnames , actname, 0) < 0 ||
ATindexOf(actargs , actarg, 0)<0) {
actnames = ATinsert(actnames, actname);
actargs = ATinsert(actargs, actarg);
}
if (extra) {
if (!ATisEmpty(vars)) ATerror(
"Flag -extra cannot be used, there are sum variables present");
DisabledEdges(
(ATermList) ATgetArgument(
(ATermAppl)ATgetArgument((ATermAppl) smd, 3), 0));
}
}
ATfprintf(stdout, "Number of sum variables: %d\n", ATgetLength(vars));
ATfprintf(stdout, "Number of different action names: %d\n",
ATgetLength(actnames));
if (pars) {
ATfprintf(stdout, "Process parameters\n");
for (i=1;!ATisEmpty(pars)&&!ATisEmpty(inits);
pars=ATgetNext(pars), inits=ATgetNext(inits),i++) {
ATerm par = ATgetFirst(pars);
ATfprintf(stdout, "%t:\t%t\tinit[%d]=%t\n", MCRLprint(
ATgetArgument((ATermAppl)par, 0)),
MCRLprint(ATgetArgument((ATermAppl)par, 1)),
i, MCRLprint(ATgetFirst(inits)));
}
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
int i, j = 0, newargc = argc +5, lastadded =0;
char **newargv = (char**) calloc(newargc, sizeof(char*));
if (!newargv) ATerror("Cannot allocate array argv");
newargv[j++] = argv[0];
ATinit(argc, argv, (ATerm*) &argc);
ATsetWarningHandler(WarningHandler);
ATsetErrorHandler(ErrorHandler);
ATprotect((ATerm*) &invars);
for (i=1;i<argc;i++) {
help(argv[i]);
if (!strcmp(argv[i],"-version")) {
version();
exit(0);
}
if (!strcmp(argv[i],"-prover")) {
proverFlag = ATtrue;
continue;
}
if (!strcmp(argv[i],"-monitor")) {
monitor = 1;
continue;
}
if (!strcmp(argv[i],"-compile") || !strcmp(argv[i],"-no-compile")) {
if (!compile) {
write = !strcmp(argv[i],"-compile")?ATtrue:ATfalse;
compile = calloc(256, sizeof(char));
MCRLsetOutputFile(compile);
strcpy(compile, argv[argc-1]);
if (strrchr(compile,'.')) *(strrchr(compile,'.'))='\0';
strcat(compile,".so");
{int k;
for (k=0;k<argc && strcmp(argv[k],"-alt");k++);
if (k==argc) {
newargv[j++]="-alt";
newargv[j++]="rw";
}
}
newargv[j++]=write?"-write-so":"-read-so";
newargv[j++]= compile;
lastadded = j;
}
continue;
}
if (!strcmp(argv[i],"-invariant")) {
if ((++i)<argc && strncmp(argv[i],"-",1)) {
char *name = argv[i];
if (invariant) ATerror("flag -invariant already present");
proverFlag = ATtrue;
invariant = fopen(name,"r");
if (!invariant) ATerror("Cannot open file %s", name);
continue;
}
ATerror("Option %s needs argument.\n",argv[i-1]);
}
j=MCRLcopyOption(newargv, argv, argc, i, j);
}
if (lastadded>0 && j==lastadded)
ATerror("Last argument must be file name");
if (proverFlag) {
if (!MCRLinit(&j, &newargv)) exit(-1);
if (!Init_prover(MCRLgetAdt(), j, newargv)) {
help("-help");
exit(1);
}
}
else {
if (!MCRLinitRW(j, newargv)) exit(-1);
}
if (compile) {
if (write) {
exit(EXIT_SUCCESS);
}
else ATwarning("Compiled rewrite system is read from %s.so", compile);
}
Reduce();
ATwarning("Read %d summands", cnt);
ATwarning("Written %d summands", newcnt);
MCRLoutput();
exit(EXIT_SUCCESS);
}
void init_Graph_dict()
{
ATermList afuns, terms;
_Graph_dict = ATreadFromBinaryString(_Graph_dict_baf, _Graph_dict_LEN);
ATprotect(&_Graph_dict);
afuns = (ATermList)ATelementAt((ATermList)_Graph_dict, 0);
afun16 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun16);
afuns = ATgetNext(afuns);
afun15 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun15);
afuns = ATgetNext(afuns);
afun14 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun14);
afuns = ATgetNext(afuns);
afun13 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun13);
afuns = ATgetNext(afuns);
afun39 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun39);
afuns = ATgetNext(afuns);
afun38 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun38);
afuns = ATgetNext(afuns);
afun19 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun19);
afuns = ATgetNext(afuns);
afun37 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun37);
afuns = ATgetNext(afuns);
afun18 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun18);
afuns = ATgetNext(afuns);
afun36 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun36);
afuns = ATgetNext(afuns);
afun17 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun17);
afuns = ATgetNext(afuns);
afun35 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun35);
afuns = ATgetNext(afuns);
afun22 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun22);
afuns = ATgetNext(afuns);
afun40 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun40);
afuns = ATgetNext(afuns);
afun23 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun23);
afuns = ATgetNext(afuns);
afun41 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun41);
afuns = ATgetNext(afuns);
afun20 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun20);
afuns = ATgetNext(afuns);
afun21 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun21);
afuns = ATgetNext(afuns);
afun4 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun4);
afuns = ATgetNext(afuns);
afun5 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun5);
afuns = ATgetNext(afuns);
afun2 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun2);
afuns = ATgetNext(afuns);
afun3 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun3);
afuns = ATgetNext(afuns);
afun0 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun0);
afuns = ATgetNext(afuns);
afun1 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun1);
afuns = ATgetNext(afuns);
afun29 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun29);
afuns = ATgetNext(afuns);
afun28 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun28);
afuns = ATgetNext(afuns);
afun8 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun8);
afuns = ATgetNext(afuns);
afun25 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun25);
afuns = ATgetNext(afuns);
afun24 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun24);
afuns = ATgetNext(afuns);
afun9 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun9);
afuns = ATgetNext(afuns);
afun6 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun6);
afuns = ATgetNext(afuns);
afun27 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun27);
afuns = ATgetNext(afuns);
afun7 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun7);
afuns = ATgetNext(afuns);
afun26 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun26);
afuns = ATgetNext(afuns);
afun31 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun31);
afuns = ATgetNext(afuns);
afun32 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun32);
afuns = ATgetNext(afuns);
afun33 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun33);
afuns = ATgetNext(afuns);
afun34 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun34);
afuns = ATgetNext(afuns);
afun10 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun10);
afuns = ATgetNext(afuns);
afun11 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun11);
afuns = ATgetNext(afuns);
afun12 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun12);
afuns = ATgetNext(afuns);
afun30 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
ATprotectAFun(afun30);
afuns = ATgetNext(afuns);
terms = (ATermList)ATelementAt((ATermList)_Graph_dict, 1);
}
void init_AIL_dict()
{
ATermList afuns, terms;
_AIL_dict = (ATermList)ATreadFromBinaryString(_AIL_dict_baf, _AIL_dict_LEN);
ATprotect((ATerm *)&_AIL_dict);
afuns = (ATermList)ATelementAt(_AIL_dict, 0);
AIL_afun0 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun1 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun2 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun3 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun4 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun5 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun6 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun7 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun8 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun9 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun10 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun11 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun12 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun13 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun14 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun15 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun16 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun17 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun18 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun19 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun20 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun21 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun22 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun23 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun24 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun25 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun26 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun27 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun28 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun29 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun30 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun31 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun32 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun33 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun34 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun35 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun36 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun37 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun38 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun39 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun40 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun41 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun42 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun43 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun44 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
AIL_afun45 = ATgetAFun((ATermAppl)ATgetFirst(afuns));
afuns = ATgetNext(afuns);
terms = (ATermList)ATelementAt(_AIL_dict, 1);
AIL_patternStatementListMany = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternStatementListSingle = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternStatementListEmpty = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternProgramProgram = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternArgLabel = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternArgAterm = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternArgCode = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternArgNumber = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternStatementInstruction = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternStatementLabelDef = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternInstructionWithArg = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternInstructionWithoutArg = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternSignatureListMany = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternSignatureListSingle = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternSignatureListEmpty = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternDefinitionDefault = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternSignatureWithoutPattern = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternSignatureWithPattern = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternPatternCode = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternPatternLabel = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternPatternAterm = ATgetFirst(terms);
terms = ATgetNext(terms);
AIL_patternPatternInt = ATgetFirst(terms);
terms = ATgetNext(terms);
}
