/[gcl]/gcl/lsp/gcl_loop.c
ViewVC logotype

Diff of /gcl/lsp/gcl_loop.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by camm, Sun Sep 14 02:30:35 2003 UTC revision 1.2 by camm, Sun Sep 14 02:43:06 2003 UTC
# Line 0  Line 1 
1    
2    #include "cmpinclude.h"
3    #include "gcl_loop.h"
4    void init_gcl_loop(){do_init(VV);}
5    /*      macro definition for LOOP-COPYLIST*     */
6    
7    static void L1()
8    {register object *base=vs_base;
9            register object *sup=base+VM1; VC1
10            vs_reserve(VM1);
11            check_arg(2);
12            vs_top=sup;
13            {object V1=base[0]->c.c_cdr;
14            if(endp(V1))invalid_macro_call();
15            base[2]= (V1->c.c_car);
16            V1=V1->c.c_cdr;
17            if(!endp(V1))invalid_macro_call();}
18            base[3]= list(2,VV[0],base[2]);
19            vs_top=(vs_base=base+3)+1;
20            return;
21    }
22    /*      function definition for LOOP-GENTEMP    */
23    
24    static void L2()
25    {register object *base=vs_base;
26            register object *sup=base+VM2; VC2
27            vs_reserve(VM2);
28            {object V2;
29            if(vs_top-vs_base>1) too_many_arguments();
30            if(vs_base>=vs_top){vs_top=sup;goto T1;}
31            V2=(base[0]);
32            vs_top=sup;
33            goto T2;
34            goto T1;
35    T1:;
36            V2= VV[1];
37            goto T2;
38    T2:;
39            if((symbol_value(VV[2]))==Cnil){
40            goto T5;}
41            base[1]= coerce_to_string((V2));
42            vs_top=(vs_base=base+1)+1;
43            Lgentemp();
44            return;
45            goto T5;
46    T5:;
47            vs_base=vs_top;
48            Lgensym();
49            return;
50            }
51    }
52    /*      function definition for LOOP-OPTIMIZATION-QUANTITIES    */
53    
54    static void L3()
55    {register object *base=vs_base;
56            register object *sup=base+VM3; VC3
57            vs_reserve(VM3);
58            {object V3;
59            check_arg(1);
60            V3=(base[0]);
61            vs_top=sup;
62            goto TTL;
63    TTL:;
64            base[1]= small_fixnum(1);
65            base[2]= small_fixnum(1);
66            base[3]= small_fixnum(1);
67            base[4]= small_fixnum(1);
68            base[5]= small_fixnum(1);
69            vs_top=(vs_base=base+1)+5;
70            return;
71            }
72    }
73    /*      function definition for HIDE-VARIABLE-REFERENCES        */
74    
75    static void L4()
76    {register object *base=vs_base;
77            register object *sup=base+VM4; VC4
78            vs_reserve(VM4);
79            {object V4;
80            object V5;
81            check_arg(2);
82            V4=(base[0]);
83            V5=(base[1]);
84            vs_top=sup;
85            goto TTL;
86    TTL:;
87            base[2]= (V5);
88            vs_top=(vs_base=base+2)+1;
89            return;
90            }
91    }
92    /*      function definition for HIDE-VARIABLE-REFERENCE */
93    
94    static void L5()
95    {register object *base=vs_base;
96            register object *sup=base+VM5; VC5
97            vs_reserve(VM5);
98            {object V6;
99            object V7;
100            object V8;
101            check_arg(3);
102            V6=(base[0]);
103            V7=(base[1]);
104            V8=(base[2]);
105            vs_top=sup;
106            goto TTL;
107    TTL:;
108            base[3]= (V8);
109            vs_top=(vs_base=base+3)+1;
110            return;
111            }
112    }
113    /*      macro definition for WITH-LOOP-LIST-COLLECTION-HEAD     */
114    
115    static void L6()
116    {register object *base=vs_base;
117            register object *sup=base+VM6; VC6
118            vs_reserve(VM6);
119            check_arg(2);
120            vs_top=sup;
121            {object V9=base[0]->c.c_cdr;
122            if(endp(V9))invalid_macro_call();
123            {object V10= (V9->c.c_car);
124            if(endp(V10))invalid_macro_call();
125            base[2]= (V10->c.c_car);
126            V10=V10->c.c_cdr;
127            if(endp(V10))invalid_macro_call();
128            base[3]= (V10->c.c_car);
129            V10=V10->c.c_cdr;
130            if(endp(V10)){
131            base[4]= Cnil;
132            } else {
133            base[4]= (V10->c.c_car);
134            V10=V10->c.c_cdr;}
135            if(!endp(V10))invalid_macro_call();}
136            V9=V9->c.c_cdr;
137            base[5]= V9;}
138            {object V11;
139            if(base[4]==Cnil){
140            V11= Cnil;
141            goto T14;}
142            V12= list(2,base[4],Cnil);
143            V11= make_cons(/* INLINE-ARGS */V12,Cnil);
144            goto T14;
145    T14:;
146            V13= list(2,base[2],VV[4]);
147            base[6]= listA(3,VV[3],listA(3,/* INLINE-ARGS */V13,list(2,base[3],base[2]),(V11)),base[5]);
148            vs_top=(vs_base=base+6)+1;
149            return;}
150    }
151    /*      macro definition for LOOP-COLLECT-RPLACD        */
152    
153    static void L7()
154    {register object *base=vs_base;
155            register object *sup=base+VM7; VC7
156            vs_reserve(VM7);
157            check_arg(2);
158            vs_top=sup;
159            {object V14=base[0]->c.c_cdr;
160            if(endp(V14))invalid_macro_call();
161            {object V15= (V14->c.c_car);
162            if(endp(V15))invalid_macro_call();
163            base[2]= (V15->c.c_car);
164            V15=V15->c.c_cdr;
165            if(endp(V15))invalid_macro_call();
166            base[3]= (V15->c.c_car);
167            V15=V15->c.c_cdr;
168            if(endp(V15)){
169            base[4]= Cnil;
170            } else {
171            base[4]= (V15->c.c_car);
172            V15=V15->c.c_cdr;}
173            if(!endp(V15))invalid_macro_call();}
174            V14=V14->c.c_cdr;
175            if(endp(V14))invalid_macro_call();
176            base[5]= (V14->c.c_car);
177            V14=V14->c.c_cdr;
178            if(!endp(V14))invalid_macro_call();}
179            base[6]= base[5];
180            base[7]= base[1];
181            vs_top=(vs_base=base+6)+2;
182            Lmacroexpand();
183            vs_top=sup;
184            base[5]= vs_base[0];
185            {register object V17;
186            V17= Cnil;
187            if(!(type_of(base[5])==t_cons)){
188            goto T20;}
189            if(!((car(base[5]))==(VV[5]))){
190            goto T24;}
191            V18 = make_fixnum((long)length(cdr(base[5])));
192            V17= one_minus(V18);
193            goto T20;
194            goto T24;
195    T24:;
196            {register object x= car(base[5]),V19= VV[6];
197            while(!endp(V19))
198            if(eql(x,V19->c.c_car)){
199            goto T28;
200            }else V19=V19->c.c_cdr;
201            goto T20;}
202            goto T28;
203    T28:;
204            if((cddr(base[5]))==Cnil){
205            goto T20;}
206            base[6]= base[5];
207            vs_top=(vs_base=base+6)+1;
208            Llast();
209            vs_top=sup;
210            V21= vs_base[0];
211            {register object x= car(V21),V20= VV[7];
212            while(!endp(V20))
213            if(eql(x,V20->c.c_car)){
214            goto T32;
215            }else V20=V20->c.c_cdr;
216            goto T20;}
217            goto T32;
218    T32:;
219            V22 = make_fixnum((long)length(cdr(base[5])));
220            V17= number_minus(V22,small_fixnum(2));
221            goto T20;
222    T20:;
223            {object V23;
224            if(((V17))!=Cnil){
225            goto T38;}
226            V24= list(3,VV[9],list(2,VV[10],base[3]),base[5]);
227            V23= list(3,VV[8],/* INLINE-ARGS */V24,list(3,VV[11],base[3],list(2,VV[12],list(2,VV[10],base[3]))));
228            goto T36;
229            goto T38;
230    T38:;
231            if(!(number_compare((V17),small_fixnum(0))<0)){
232            goto T41;}
233            base[6]= Cnil;
234            vs_top=(vs_base=base+6)+1;
235            return;
236            goto T41;
237    T41:;
238            if(!(number_compare((V17),small_fixnum(0))==0)){
239            goto T44;}
240            V23= list(3,VV[13],base[3],list(3,VV[11],base[3],base[5]));
241            goto T36;
242            goto T44;
243    T44:;
244            base[6]= list(3,VV[9],list(2,VV[10],base[3]),base[5]);
245            base[7]= (V17);
246            vs_top=(vs_base=base+6)+2;
247            L8(base);
248            vs_top=sup;
249            V25= vs_base[0];
250            V23= list(3,VV[11],base[3],V25);
251            goto T36;
252    T36:;
253            if((base[4])==Cnil){
254            goto T49;}
255            V23= list(3,VV[14],(V23),list(3,VV[11],base[4],list(2,VV[10],base[2])));
256            goto T49;
257    T49:;
258            base[6]= (V23);
259            vs_top=(vs_base=base+6)+1;
260            return;}}
261    }
262    /*      macro definition for LOOP-COLLECT-ANSWER        */
263    
264    static void L9()
265    {register object *base=vs_base;
266            register object *sup=base+VM8; VC8
267            vs_reserve(VM8);
268            check_arg(2);
269            vs_top=sup;
270            {object V26=base[0]->c.c_cdr;
271            if(endp(V26))invalid_macro_call();
272            base[2]= (V26->c.c_car);
273            V26=V26->c.c_cdr;
274            if(endp(V26)){
275            base[3]= Cnil;
276            } else {
277            base[3]= (V26->c.c_car);
278            V26=V26->c.c_cdr;}
279            if(!endp(V26))invalid_macro_call();}
280            if(base[3]!=Cnil){
281            vs_top=(vs_base=base+3)+1;
282            return;}
283            base[4]= list(2,VV[10],base[2]);
284            vs_top=(vs_base=base+4)+1;
285            return;
286    }
287    /*      function definition for MAKE-LOOP-MINIMAX-INTERNAL      */
288    
289    static void L10()
290    {register object *base=vs_base;
291            register object *sup=base+VM9; VC9
292            vs_reserve(VM9);
293            {object V27;
294            object V28;
295            object V29;
296            object V30;
297            object V31;
298            object V32;
299            parse_key(vs_base,FALSE,FALSE,6,VV[21],VV[22],VV[23],VV[25],VV[27],VV[28]);
300            vs_top=sup;
301            V27=(base[0]);
302            V28=(base[1]);
303            V29=(base[2]);
304            V30=(base[3]);
305            V31=(base[4]);
306            V32=(base[5]);
307            base[12]= VV[18];
308            base[13]= (V27);
309            base[14]= (V28);
310            base[15]= (V29);
311            base[16]= (V30);
312            base[17]= (V31);
313            base[18]= (V32);
314            vs_top=(vs_base=base+12)+7;
315            siLmake_structure();
316            return;
317            }
318    }
319    /*      function definition for MAKE-LOOP-MINIMAX       */
320    
321    static void L11()
322    {register object *base=vs_base;
323            register object *sup=base+VM10; VC10
324            vs_reserve(VM10);
325            {object V33;
326            object V34;
327            check_arg(2);
328            V33=(base[0]);
329            V34=(base[1]);
330            vs_top=sup;
331            goto TTL;
332    TTL:;
333            {object V35;
334            base[2]= (V34);
335            base[3]= symbol_value(VV[19]);
336            base[4]= VV[20];
337            base[5]= symbol_function(VV[326]);
338            vs_top=(vs_base=base+2)+4;
339            Lassoc();
340            vs_top=sup;
341            V36= vs_base[0];
342            V35= cdr(V36);
343            base[2]= VV[21];
344            base[3]= (V33);
345            base[4]= VV[22];
346            base[5]= (V34);
347            base[6]= VV[23];
348            base[8]= VV[24];
349            vs_top=(vs_base=base+8)+1;
350            (void) (*Lnk327)();
351            vs_top=sup;
352            base[7]= vs_base[0];
353            base[8]= VV[25];
354            if(((V35))==Cnil){
355            goto T76;}
356            base[9]= Cnil;
357            goto T75;
358            goto T76;
359    T76:;
360            base[10]= VV[26];
361            vs_top=(vs_base=base+10)+1;
362            (void) (*Lnk327)();
363            vs_top=sup;
364            base[9]= vs_base[0];
365            goto T75;
366    T75:;
367            base[10]= VV[27];
368            base[11]= Cnil;
369            base[12]= VV[28];
370            base[13]= (V35);
371            vs_top=(vs_base=base+2)+12;
372            (void) (*Lnk328)();
373            return;}
374            }
375    }
376    /*      function definition for LOOP-NOTE-MINIMAX-OPERATION     */
377    
378    static void L12()
379    {register object *base=vs_base;
380            register object *sup=base+VM11; VC11
381            vs_reserve(VM11);
382            {object V37;
383            register object V38;
384            check_arg(2);
385            V37=(base[0]);
386            V38=(base[1]);
387            vs_top=sup;
388            goto TTL;
389    TTL:;
390            {object V41;
391            base[3]= V37;
392            base[4]= structure_ref(V38,VV[18],4);
393            vs_top=(vs_base=base+3)+2;
394            Ladjoin();
395            vs_top=sup;
396            V41= vs_base[0];
397            (void)(structure_set(V38,VV[18],4,(V41)));}
398            V42= structure_ref((V38),VV[18],4);
399            if((cdr(/* INLINE-ARGS */V42))==Cnil){
400            goto T87;}
401            if((structure_ref((V38),VV[18],3))!=Cnil){
402            goto T87;}
403            base[2]= VV[26];
404            vs_top=(vs_base=base+2)+1;
405            (void) (*Lnk327)();
406            vs_top=sup;
407            V43= vs_base[0];
408            (void)(structure_set((V38),VV[18],3,V43));
409            goto T87;
410    T87:;
411            base[2]= (V37);
412            vs_top=(vs_base=base+2)+1;
413            return;
414            }
415    }
416    /*      macro definition for WITH-MINIMAX-VALUE */
417    
418    static void L13()
419    {register object *base=vs_base;
420            register object *sup=base+VM12; VC12
421            vs_reserve(VM12);
422            check_arg(2);
423            vs_top=sup;
424            {object V44=base[0]->c.c_cdr;
425            if(endp(V44))invalid_macro_call();
426            base[2]= (V44->c.c_car);
427            V44=V44->c.c_cdr;
428            base[3]= V44;}
429            {object V45;
430            object V46;
431            object V47;
432            register object V48;
433            register object V49;
434            object V50;
435            object V51;
436            base[4]= structure_ref(base[2],VV[18],1);
437            vs_top=(vs_base=base+4)+1;
438            (void) (*Lnk329)();
439            vs_top=sup;
440            V45= vs_base[0];
441            V52= structure_ref(base[2],VV[18],4);
442            V46= car(/* INLINE-ARGS */V52);
443            V47= structure_ref(base[2],VV[18],5);
444            V48= structure_ref(base[2],VV[18],0);
445            V49= structure_ref(base[2],VV[18],2);
446            V50= structure_ref(base[2],VV[18],3);
447            V51= structure_ref(base[2],VV[18],1);
448            if(((V50))==Cnil){
449            goto T103;}
450            V53= list(2,(V48),(V45));
451            V54= list(2,(V49),(V45));
452            V55= list(3,/* INLINE-ARGS */V53,/* INLINE-ARGS */V54,list(2,(V50),Cnil));
453            base[4]= listA(4,VV[29],/* INLINE-ARGS */V55,list(2,VV[30],list(4,VV[31],(V51),(V48),(V49))),base[3]);
454            vs_top=(vs_base=base+4)+1;
455            return;
456            goto T103;
457    T103:;
458            if(!(((V46))==(VV[32]))){
459            goto T107;}
460            V56= car((V47));
461            goto T105;
462            goto T107;
463    T107:;
464            V56= cadr((V47));
465            goto T105;
466    T105:;
467            V57= list(2,(V48),V56);
468            V58= list(2,/* INLINE-ARGS */V57,list(2,(V49),(V45)));
469            base[4]= listA(4,VV[29],/* INLINE-ARGS */V58,list(2,VV[30],list(4,VV[31],(V51),(V48),(V49))),base[3]);
470            vs_top=(vs_base=base+4)+1;
471            return;}
472    }
473    /*      macro definition for LOOP-ACCUMULATE-MINIMAX-VALUE      */
474    
475    static void L14()
476    {register object *base=vs_base;
477            register object *sup=base+VM13; VC13
478            vs_reserve(VM13);
479            check_arg(2);
480            vs_top=sup;
481            {object V59=base[0]->c.c_cdr;
482            if(endp(V59))invalid_macro_call();
483            base[2]= (V59->c.c_car);
484            V59=V59->c.c_cdr;
485            if(endp(V59))invalid_macro_call();
486            base[3]= (V59->c.c_car);
487            V59=V59->c.c_cdr;
488            if(endp(V59))invalid_macro_call();
489            base[4]= (V59->c.c_car);
490            V59=V59->c.c_cdr;
491            if(!endp(V59))invalid_macro_call();}
492            {object V60;
493            object V61;
494            register object V62;
495            object V63;
496            V60= structure_ref(base[2],VV[18],0);
497            V61= structure_ref(base[2],VV[18],2);
498            V62= structure_ref(base[2],VV[18],3);
499            base[9]= Ct;
500            base[10]= structure_ref(base[2],VV[18],0);
501            {object V65= base[3];
502            if((V65!= VV[32]))goto T117;
503            V64= VV[33];
504            goto T116;
505            goto T117;
506    T117:;
507            if((V65!= VV[330]))goto T118;
508            V64= VV[34];
509            goto T116;
510            goto T118;
511    T118:;
512            FEerror("The ECASE key value ~s is illegal.",1,V65);
513            V64= Cnil;
514            goto T116;}
515            goto T116;
516    T116:;
517            base[11]= list(3,V64,(V61),(V60));
518            vs_top=(vs_base=base+9)+3;
519            (void) (*Lnk331)();
520            vs_top=sup;
521            V63= vs_base[0];
522            V66= list(3,VV[11],(V61),base[4]);
523            if(((V62))==Cnil){
524            goto T121;}
525            V67= list(3,VV[35],list(2,VV[36],(V62)),(V63));
526            goto T119;
527            goto T121;
528    T121:;
529            V67= (V63);
530            goto T119;
531    T119:;
532            if((V62)==Cnil){
533            V68= Cnil;
534            goto T123;}
535            V68= list(2,(V62),Ct);
536            goto T123;
537    T123:;
538            V69= list(2,(V60),(V61));
539            V70= append(V68,/* INLINE-ARGS */V69);
540            base[9]= list(3,VV[14],/* INLINE-ARGS */V66,list(3,VV[8],V67,make_cons(VV[11],/* INLINE-ARGS */V70)));
541            vs_top=(vs_base=base+9)+1;
542            return;}
543    }
544    /*      function definition for LOOP-TEQUAL     */
545    
546    static void L15()
547    {register object *base=vs_base;
548            register object *sup=base+VM14; VC14
549            vs_reserve(VM14);
550            {object V71;
551            object V72;
552            check_arg(2);
553            V71=(base[0]);
554            V72=(base[1]);
555            vs_top=sup;
556            goto TTL;
557    TTL:;
558            if(type_of((V71))==t_symbol){
559            goto T124;}
560            base[2]= Cnil;
561            vs_top=(vs_base=base+2)+1;
562            return;
563            goto T124;
564    T124:;
565            base[2]= (V71);
566            base[3]= (V72);
567            vs_top=(vs_base=base+2)+2;
568            Lstring_eq();
569            return;
570            }
571    }
572    /*      function definition for LOOP-TASSOC     */
573    
574    static void L16()
575    {register object *base=vs_base;
576            register object *sup=base+VM15; VC15
577            vs_reserve(VM15);
578            {object V73;
579            object V74;
580            check_arg(2);
581            V73=(base[0]);
582            V74=(base[1]);
583            vs_top=sup;
584            goto TTL;
585    TTL:;
586            if(type_of((V73))==t_symbol){
587            goto T128;}
588            base[2]= Cnil;
589            vs_top=(vs_base=base+2)+1;
590            return;
591            goto T128;
592    T128:;
593            base[2]= (V73);
594            base[3]= (V74);
595            base[4]= VV[20];
596            base[5]= symbol_function(VV[332]);
597            vs_top=(vs_base=base+2)+4;
598            Lassoc();
599            return;
600            }
601    }
602    /*      function definition for LOOP-TMEMBER    */
603    
604    static void L17()
605    {register object *base=vs_base;
606            register object *sup=base+VM16; VC16
607            vs_reserve(VM16);
608            {object V75;
609            object V76;
610            check_arg(2);
611            V75=(base[0]);
612            V76=(base[1]);
613            vs_top=sup;
614            goto TTL;
615    TTL:;
616            if(type_of((V75))==t_symbol){
617            goto T134;}
618            base[2]= Cnil;
619            vs_top=(vs_base=base+2)+1;
620            return;
621            goto T134;
622    T134:;
623            base[2]= (V75);
624            base[3]= (V76);
625            base[4]= VV[20];
626            base[5]= symbol_function(VV[332]);
627            vs_top=(vs_base=base+2)+4;
628            Lmember();
629            return;
630            }
631    }
632    /*      function definition for LOOP-LOOKUP-KEYWORD     */
633    
634    static void L18()
635    {register object *base=vs_base;
636            register object *sup=base+VM17; VC17
637            vs_reserve(VM17);
638            {object V77;
639            object V78;
640            check_arg(2);
641            V77=(base[0]);
642            V78=(base[1]);
643            vs_top=sup;
644            goto TTL;
645    TTL:;
646            if(type_of((V77))==t_symbol){
647            goto T140;}
648            base[2]= Cnil;
649            vs_top=(vs_base=base+2)+1;
650            return;
651            goto T140;
652    T140:;
653            base[3]= symbol_name((V77));
654            base[4]= (V78);
655            vs_top=(vs_base=base+3)+2;
656            Lgethash();
657            vs_top=sup;
658            base[2]= vs_base[0];
659            vs_top=(vs_base=base+2)+1;
660            return;
661            }
662    }
663    /*      macro definition for LOOP-STORE-TABLE-DATA      */
664    
665    static void L19()
666    {register object *base=vs_base;
667            register object *sup=base+VM18; VC18
668            vs_reserve(VM18);
669            check_arg(2);
670            vs_top=sup;
671            {object V79=base[0]->c.c_cdr;
672            if(endp(V79))invalid_macro_call();
673            base[2]= (V79->c.c_car);
674            V79=V79->c.c_cdr;
675            if(endp(V79))invalid_macro_call();
676            base[3]= (V79->c.c_car);
677            V79=V79->c.c_cdr;
678            if(endp(V79))invalid_macro_call();
679            base[4]= (V79->c.c_car);
680            V79=V79->c.c_cdr;
681            if(!endp(V79))invalid_macro_call();}
682            base[5]= list(3,VV[9],list(3,VV[37],list(2,VV[38],base[2]),base[3]),base[4]);
683            vs_top=(vs_base=base+5)+1;
684            return;
685    }
686    /*      function definition for MAKE-LOOP-UNIVERSE      */
687    
688    static void L20()
689    {register object *base=vs_base;
690            register object *sup=base+VM19; VC19
691            vs_reserve(VM19);
692            {object V80;
693            object V81;
694            object V82;
695            object V83;
696            object V84;
697            object V85;
698            object V86;
699            object V87;
700            parse_key(vs_base,FALSE,FALSE,8,VV[53],VV[55],VV[54],VV[56],VV[60],VV[59],VV[57],VV[58]);
701            vs_top=sup;
702            V80=(base[0]);
703            V81=(base[1]);
704            V82=(base[2]);
705            V83=(base[3]);
706            V84=(base[4]);
707            V85=(base[5]);
708            V86=(base[6]);
709            V87=(base[7]);
710            base[16]= VV[39];
711            base[17]= (V80);
712            base[18]= (V81);
713            base[19]= (V82);
714            base[20]= (V83);
715            base[21]= (V84);
716            base[22]= (V85);
717            base[23]= (V86);
718            base[24]= (V87);
719            vs_top=(vs_base=base+16)+9;
720            siLmake_structure();
721            return;
722            }
723    }
724    /*      function definition for PRINT-LOOP-UNIVERSE     */
725    
726    static void L21()
727    {register object *base=vs_base;
728            register object *sup=base+VM20; VC20
729            vs_reserve(VM20);
730            {object V88;
731            object V89;
732            object V90;
733            check_arg(3);
734            V88=(base[0]);
735            V89=(base[1]);
736            V90=(base[2]);
737            vs_top=sup;
738            goto TTL;
739    TTL:;
740            {object V91;
741            V93= structure_ref((V88),VV[39],6);
742            {object V92= /* INLINE-ARGS */V93;
743            if((V92!= Cnil))goto T155;
744            V91= VV[40];
745            goto T154;
746            goto T155;
747    T155:;
748            if((V92!= Ct))goto T156;
749            V91= VV[41];
750            goto T154;
751            goto T156;
752    T156:;
753            if((V92!= VV[307]))goto T157;
754            V91= VV[42];
755            goto T154;
756            goto T157;
757    T157:;
758            V91= structure_ref((V88),VV[39],6);}
759            goto T154;
760    T154:;
761            base[3]= (V89);
762            base[4]= VV[43];
763            base[6]= (V88);
764            vs_top=(vs_base=base+6)+1;
765            Ltype_of();
766            vs_top=sup;
767            base[5]= vs_base[0];
768            base[6]= (V91);
769            vs_top=(vs_base=base+3)+4;
770            Lformat();
771            return;}
772            }
773    }
774    /*      function definition for MAKE-STANDARD-LOOP-UNIVERSE     */
775    
776    static void L22()
777    {register object *base=vs_base;
778            register object *sup=base+VM21; VC21
779            vs_reserve(VM21);
780            bds_check;
781            {object V94;
782            object V95;
783            object V96;
784            object V97;
785            object V98;
786            object V99;
787            register object V100;
788            parse_key(vs_base,FALSE,FALSE,7,VV[53],VV[54],VV[55],VV[56],VV[59],VV[60],VV[57]);
789            vs_top=sup;
790            V94=(base[0]);
791            V95=(base[1]);
792            V96=(base[2]);
793            V97=(base[3]);
794            V98=(base[4]);
795            V99=(base[5]);
796            V100=(base[6]);
797            bds_bind(VV[44],small_fixnum(4));
798            bds_bind(VV[45],small_fixnum(4));
799            goto T165;
800    T165:;
801            base[16]= (V100);
802            base[17]= VV[46];
803            vs_top=(vs_base=base+16)+2;
804            (void) (*Lnk333)();
805            vs_top=sup;
806            if((vs_base[0])==Cnil){
807            goto T166;}
808            bds_unwind1;
809            bds_unwind1;
810            goto T163;
811            goto T166;
812    T166:;
813            base[16]= VV[47];
814            base[17]= VV[48];
815            base[18]= VV[49];
816            base[19]= (V100);
817            base[20]= VV[46];
818            vs_top=(vs_base=base+16)+5;
819            Lcerror();
820            vs_top=sup;
821            base[16]= symbol_value(VV[50]);
822            base[17]= VV[51];
823            base[18]= VV[49];
824            vs_top=(vs_base=base+16)+3;
825            Lformat();
826            vs_top=sup;
827            base[16]= symbol_value(VV[50]);
828            vs_top=(vs_base=base+16)+1;
829            Lfinish_output();
830            vs_top=sup;
831            vs_base=vs_top;
832            Lread();
833            vs_top=sup;
834            V100= vs_base[0];
835            base[16]= symbol_value(VV[50]);
836            base[17]= VV[52];
837            vs_top=(vs_base=base+16)+2;
838            Lformat();
839            vs_top=sup;
840            goto T165;
841            goto T163;
842    T163:;
843            base[14]= VV[53];
844            base[16]= (V94);
845            vs_top=(vs_base=base+16)+1;
846            L23(base);
847            vs_top=sup;
848            base[15]= vs_base[0];
849            base[16]= VV[54];
850            base[18]= (V95);
851            vs_top=(vs_base=base+18)+1;
852            L23(base);
853            vs_top=sup;
854            base[17]= vs_base[0];
855            base[18]= VV[55];
856            base[20]= (V96);
857            vs_top=(vs_base=base+20)+1;
858            L23(base);
859            vs_top=sup;
860            base[19]= vs_base[0];
861            base[20]= VV[56];
862            base[22]= (V97);
863            vs_top=(vs_base=base+22)+1;
864            L23(base);
865            vs_top=sup;
866            base[21]= vs_base[0];
867            base[22]= VV[57];
868            base[23]= (V100);
869            base[24]= VV[58];
870            base[25]= (((((V100))==Cnil?Ct:Cnil))==Cnil?Ct:Cnil);
871            base[26]= VV[59];
872            base[28]= (V98);
873            vs_top=(vs_base=base+28)+1;
874            L23(base);
875            vs_top=sup;
876            base[27]= vs_base[0];
877            base[28]= VV[60];
878            {object V101;
879            object V102;
880            V101= make_fixnum((long)length((V99)));
881            base[32]= VV[61];
882            if(!(number_compare((V101),small_fixnum(10))<0)){
883            goto T217;}
884            base[33]= small_fixnum(10);
885            goto T215;
886            goto T217;
887    T217:;
888            base[33]= (V101);
889            goto T215;
890    T215:;
891            base[34]= VV[20];
892            base[35]= symbol_function(VV[334]);
893            vs_top=(vs_base=base+32)+4;
894            Lmake_hash_table();
895            vs_top=sup;
896            V102= vs_base[0];
897            {register object V103;
898            register object V104;
899            V103= (V99);
900            V104= car((V103));
901            goto T225;
902    T225:;
903            if(!(endp_prop((V103)))){
904            goto T226;}
905            goto T221;
906            goto T226;
907    T226:;
908            if(!(type_of((V104))!=t_cons)){
909            goto T232;}
910            base[33]= V104;
911            base[34]= V102;
912            base[35]= V104;
913            vs_top=(vs_base=base+33)+3;
914            siLhash_set();
915            vs_top=sup;
916            goto T230;
917            goto T232;
918    T232:;
919            {object V108;
920            object V110;
921            V108= car((V104));
922            V110= cadr((V104));
923            base[35]= (V108);
924            base[36]= V102;
925            base[37]= (V110);
926            vs_top=(vs_base=base+35)+3;
927            siLhash_set();
928            vs_top=sup;}
929            goto T230;
930    T230:;
931            V103= cdr((V103));
932            V104= car((V103));
933            goto T225;}
934            goto T221;
935    T221:;
936            base[29]= (V102);}
937            vs_top=(vs_base=base+14)+16;
938            (void) (*Lnk335)();
939            return;
940            }
941    }
942    /*      function definition for LOOP-MAKE-PSETQ */
943    
944    static void L24()
945    {register object *base=vs_base;
946            register object *sup=base+VM22; VC22
947            vs_reserve(VM22);
948            {register object V111;
949            check_arg(1);
950            V111=(base[0]);
951            vs_top=sup;
952            goto TTL;
953    TTL:;
954            if((V111)==Cnil){
955            base[1]= Cnil;
956            vs_top=(vs_base=base+1)+1;
957            return;}
958            V112= car((V111));
959            if((cddr((V111)))!=Cnil){
960            goto T250;}
961            V113= cadr((V111));
962            goto T248;
963            goto T250;
964    T250:;
965            V114= cadr((V111));
966            base[2]= cddr((V111));
967            vs_top=(vs_base=base+2)+1;
968            (void) (*Lnk336)();
969            vs_top=sup;
970            V115= vs_base[0];
971            V113= list(3,VV[62],/* INLINE-ARGS */V114,V115);
972            goto T248;
973    T248:;
974            base[1]= list(2,/* INLINE-ARGS */V112,V113);
975            vs_top=(vs_base=base+1)+1;
976            (void) (*Lnk337)();
977            return;
978            }
979    }
980    /*      function definition for LOOP-MAKE-DESETQ        */
981    
982    static void L25()
983    {register object *base=vs_base;
984            register object *sup=base+VM23; VC23
985            vs_reserve(VM23);
986            {object V116;
987            check_arg(1);
988            V116=(base[0]);
989            vs_top=sup;
990            goto TTL;
991    TTL:;
992            if(((V116))!=Cnil){
993            goto T255;}
994            base[1]= Cnil;
995            vs_top=(vs_base=base+1)+1;
996            return;
997            goto T255;
998    T255:;
999            if((symbol_value(VV[63]))==Cnil){
1000            goto T259;}
1001            V117= cadr(symbol_value(VV[63]));
1002            goto T257;
1003            goto T259;
1004    T259:;
1005            V117= VV[64];
1006            goto T257;
1007    T257:;
1008            base[1]= make_cons(V117,(V116));
1009            vs_top=(vs_base=base+1)+1;
1010            return;
1011            }
1012    }
1013    /*      macro definition for LOOP-REALLY-DESETQ */
1014    
1015    static void L26()
1016    {register object *base=vs_base;
1017            register object *sup=base+VM24; VC24
1018            vs_reserve(VM24);
1019            check_arg(2);
1020            vs_top=sup;
1021            {object V118=base[0]->c.c_cdr;
1022            base[2]= V118;}
1023            {register object V119;
1024            V119= Cnil;
1025            goto T262;
1026    T262:;
1027            if((base[2])!=Cnil){
1028            goto T263;}
1029            if((cdr((V119)))!=Cnil){
1030            goto T267;}
1031            base[3]= car((V119));
1032            vs_top=(vs_base=base+3)+1;
1033            return;
1034            goto T267;
1035    T267:;
1036            V120= nreverse((V119));
1037            base[3]= make_cons(VV[14],/* INLINE-ARGS */V120);
1038            vs_top=(vs_base=base+3)+1;
1039            return;
1040            goto T263;
1041    T263:;
1042            {register object V121;
1043            V121= car(base[2]);
1044            base[2]= cdr(base[2]);
1045            base[4]= (V121);}
1046            {register object V122;
1047            V122= car(base[2]);
1048            base[2]= cdr(base[2]);
1049            base[5]= (V122);}
1050            vs_top=(vs_base=base+4)+2;
1051            L28(base);
1052            vs_top=sup;
1053            base[3]= vs_base[0];
1054            base[4]= (V119);
1055            vs_top=(vs_base=base+3)+2;
1056            Lrevappend();
1057            vs_top=sup;
1058            V119= vs_base[0];
1059            goto T262;}
1060    }
1061    /*      function definition for LOOP-CONSTANT-FOLD-IF-POSSIBLE  */
1062    
1063    static void L29()
1064    {register object *base=vs_base;
1065            register object *sup=base+VM25; VC25
1066            vs_reserve(VM25);
1067            {object V123;
1068            object V124;
1069            if(vs_top-vs_base<1) too_few_arguments();
1070            if(vs_top-vs_base>2) too_many_arguments();
1071            V123=(base[0]);
1072            vs_base=vs_base+1;
1073            if(vs_base>=vs_top){vs_top=sup;goto T284;}
1074            V124=(base[1]);
1075            vs_top=sup;
1076            goto T285;
1077            goto T284;
1078    T284:;
1079            V124= Cnil;
1080            goto T285;
1081    T285:;
1082            {register object V126;
1083            register object V127;
1084            V126= Cnil;
1085            V127= Cnil;
1086            base[2]= V123;
1087            vs_top=(vs_base=base+2)+1;
1088            Lconstantp();
1089            vs_top=sup;
1090            V126= vs_base[0];
1091            if(((V126))==Cnil){
1092            goto T287;}
1093            base[2]= V123;
1094            vs_top=(vs_base=base+2)+1;
1095            Leval();
1096            vs_top=sup;
1097            V127= vs_base[0];
1098            goto T287;
1099    T287:;
1100            if(((V126))==Cnil){
1101            goto T294;}
1102            if(((V124))==Cnil){
1103            goto T294;}
1104            base[2]= (V127);
1105            base[3]= (V124);
1106            vs_top=(vs_base=base+2)+2;
1107            (void) (*Lnk333)();
1108            vs_top=sup;
1109            if((vs_base[0])!=Cnil){
1110            goto T294;}
1111            base[2]= VV[67];
1112            base[3]= (V123);
1113            base[4]= (V127);
1114            base[5]= (V124);
1115            vs_top=(vs_base=base+2)+4;
1116            (void) (*Lnk338)();
1117            vs_top=sup;
1118            V126= Cnil;
1119            V127= Cnil;
1120            goto T294;
1121    T294:;
1122            base[2]= V123;
1123            base[3]= (V126);
1124            base[4]= (V127);
1125            vs_top=(vs_base=base+2)+3;
1126            return;}
1127            }
1128    }
1129    /*      function definition for LOOP-CONSTANTP  */
1130    
1131    static void L30()
1132    {register object *base=vs_base;
1133            register object *sup=base+VM26; VC26
1134            vs_reserve(VM26);
1135            {object V128;
1136            check_arg(1);
1137            V128=(base[0]);
1138            vs_top=sup;
1139            goto TTL;
1140    TTL:;
1141            base[1]= (V128);
1142            vs_top=(vs_base=base+1)+1;
1143            Lconstantp();
1144            return;
1145            }
1146    }
1147    /*      function definition for LOOP-CODE-DUPLICATION-THRESHOLD */
1148    
1149    static void L31()
1150    {register object *base=vs_base;
1151            register object *sup=base+VM27; VC27
1152            vs_reserve(VM27);
1153            {object V129;
1154            check_arg(1);
1155            V129=(base[0]);
1156            vs_top=sup;
1157            goto TTL;
1158    TTL:;
1159            {object V130;
1160            object V131;
1161            base[1]= (V129);
1162            vs_top=(vs_base=base+1)+1;
1163            (void) (*Lnk339)();
1164            if(vs_base>=vs_top){vs_top=sup;goto T317;}
1165            V130= vs_base[0];
1166            vs_base++;
1167            if(vs_base>=vs_top){vs_top=sup;goto T318;}
1168            V131= vs_base[0];
1169            vs_top=sup;
1170            goto T319;
1171            goto T317;
1172    T317:;
1173            V130= Cnil;
1174            goto T318;
1175    T318:;
1176            V131= Cnil;
1177            goto T319;
1178    T319:;
1179            V132= number_minus((V130),(V131));
1180            V133= number_times(/* INLINE-ARGS */V132,small_fixnum(10));
1181            base[1]= number_plus(small_fixnum(40),/* INLINE-ARGS */V133);
1182            vs_top=(vs_base=base+1)+1;
1183            return;}
1184            }
1185    }
1186    /*      macro definition for LOOP-BODY  */
1187    
1188    static void L32()
1189    {register object *base=vs_base;
1190            register object *sup=base+VM28; VC28
1191            vs_reserve(VM28);
1192            check_arg(2);
1193            vs_top=sup;
1194            {object V134=base[0]->c.c_cdr;
1195            if(endp(V134))invalid_macro_call();
1196            base[2]= (V134->c.c_car);
1197            V134=V134->c.c_cdr;
1198            if(endp(V134))invalid_macro_call();
1199            base[3]= (V134->c.c_car);
1200            V134=V134->c.c_cdr;
1201            if(endp(V134))invalid_macro_call();
1202            base[4]= (V134->c.c_car);
1203            V134=V134->c.c_cdr;
1204            if(endp(V134))invalid_macro_call();
1205            base[5]= (V134->c.c_car);
1206            V134=V134->c.c_cdr;
1207            if(endp(V134))invalid_macro_call();
1208            base[6]= (V134->c.c_car);
1209            V134=V134->c.c_cdr;
1210            if(!endp(V134))invalid_macro_call();
1211            base[7]= Cnil;
1212            base[8]= Cnil;
1213            base[9]= Cnil;}
1214            if(((long)length(base[3]))==((long)length(base[5]))){
1215            goto T323;}
1216            base[10]= VV[68];
1217            vs_top=(vs_base=base+10)+1;
1218            Lerror();
1219            vs_top=sup;
1220            goto T323;
1221    T323:;
1222            base[7]= reverse(base[3]);
1223            base[8]= reverse(base[5]);
1224            if((symbol_value(VV[69]))!=Cnil){
1225            goto T332;}
1226            if((base[7])!=Cnil){
1227            goto T331;}
1228            goto T332;
1229    T332:;
1230            vs_base=vs_top;
1231            L35(base);
1232            return;
1233            goto T331;
1234    T331:;
1235            {register long V135;
1236            base[10]= base[1];
1237            vs_top=(vs_base=base+10)+1;
1238            (void) (*Lnk340)();
1239            vs_top=sup;
1240            V135= fix(vs_base[0]);
1241            goto T339;
1242    T339:;
1243            goto T344;
1244    T344:;
1245            if((base[7])==Cnil){
1246            goto T346;}
1247            if(equal(car(base[7]),car(base[8]))){
1248            goto T345;}
1249            goto T346;
1250    T346:;
1251            goto T342;
1252            goto T345;
1253    T345:;
1254            {register object V136;
1255            {register object V137;
1256            V137= car(base[7]);
1257            base[7]= cdr(base[7]);
1258            V136= (V137);}
1259            base[4]= make_cons((V136),base[4]);}
1260            {register object V138;
1261            V138= car(base[8]);
1262            base[8]= cdr(base[8]);}
1263            goto T344;
1264            goto T342;
1265    T342:;
1266            if((base[7])!=Cnil){
1267            goto T363;}
1268            vs_base=vs_top;
1269            L35(base);
1270            return;
1271            goto T363;
1272    T363:;
1273            {register object V139;
1274            register object V140;
1275            register object V141;
1276            register object V142;
1277            register object V143;
1278            V139= base[7];
1279            V140= base[8];
1280            V141= Cnil;
1281            V142= small_fixnum(0);
1282            V143= Cnil;
1283            goto T368;
1284    T368:;
1285            if(((V139))!=Cnil){
1286            goto T369;}
1287            vs_base=vs_top;
1288            L35(base);
1289            return;
1290            goto T369;
1291    T369:;
1292            if(equal(car((V139)),car((V140)))){
1293            goto T375;}
1294            V141= (V139);
1295            V142= small_fixnum(0);
1296            goto T373;
1297            goto T375;
1298    T375:;
1299            base[10]= car((V139));
1300            base[11]= base[1];
1301            vs_top=(vs_base=base+10)+2;
1302            (void) (*Lnk77)();
1303            vs_top=sup;
1304            V143= vs_base[0];
1305            if(((V143))==Cnil){
1306            goto T380;}
1307            V142= number_plus((V142),(V143));
1308            V144 = make_fixnum(V135);
1309            if(!(number_compare((V142),V144)>0)){
1310            goto T373;}
1311            goto T380;
1312    T380:;
1313            {register object V145;
1314            register object V146;
1315            V145= Cnil;
1316            V146= Cnil;
1317            goto T391;
1318    T391:;
1319            {register object V147;
1320            {register object V148;
1321            V148= car(base[7]);
1322            base[7]= cdr(base[7]);
1323            V147= (V148);}
1324            V146= make_cons((V147),(V146));}
1325            {register object V149;
1326            {register object V150;
1327            V150= car(base[8]);
1328            base[8]= cdr(base[8]);
1329            V149= (V150);}
1330            V145= make_cons((V149),(V145));}
1331            if(!((base[7])==(cdr((V141))))){
1332            goto T406;}
1333            goto T389;
1334            goto T406;
1335    T406:;
1336            goto T391;
1337            goto T389;
1338    T389:;
1339            if((base[9])!=Cnil){
1340            goto T411;}
1341            {register object V151;
1342            base[9]= symbol_value(VV[70]);
1343            V151= list(3,VV[11],base[9],Ct);
1344            V146= make_cons((V151),(V146));}
1345            goto T411;
1346    T411:;
1347            {register object V152;
1348            base[12]= (V145);
1349            vs_top=(vs_base=base+12)+1;
1350            L33(base);
1351            vs_top=sup;
1352            base[11]= vs_base[0];
1353            vs_top=(vs_base=base+11)+1;
1354            L34(base);
1355            vs_top=sup;
1356            V153= vs_base[0];
1357            base[12]= (V146);
1358            vs_top=(vs_base=base+12)+1;
1359            L33(base);
1360            vs_top=sup;
1361            base[11]= vs_base[0];
1362            vs_top=(vs_base=base+11)+1;
1363            L34(base);
1364            vs_top=sup;
1365            V154= vs_base[0];
1366            V152= list(4,VV[71],base[9],V153,V154);
1367            base[4]= make_cons((V152),base[4]);}}
1368            goto T427;
1369    T427:;
1370            {register object V155;
1371            V155= car(base[8]);
1372            base[8]= cdr(base[8]);}
1373            {register object V156;
1374            {register object V157;
1375            V157= car(base[7]);
1376            base[7]= cdr(base[7]);
1377            V156= (V157);}
1378            base[4]= make_cons((V156),base[4]);}
1379            if(!((base[7])==(cdr((V139))))){
1380            goto T440;}
1381            goto T425;
1382            goto T440;
1383    T440:;
1384            goto T427;
1385            goto T425;
1386    T425:;
1387            goto T366;
1388            goto T373;
1389    T373:;
1390            V139= cdr((V139));
1391            V140= cdr((V140));
1392            goto T368;}
1393            goto T366;
1394    T366:;
1395            goto T339;}
1396    }
1397    /*      function definition for DUPLICATABLE-CODE-P     */
1398    
1399    static void L36()
1400    {register object *base=vs_base;
1401            register object *sup=base+VM29; VC29
1402            vs_reserve(VM29);
1403            {object V158;
1404            object V159;
1405            check_arg(2);
1406            V158=(base[0]);
1407            V159=(base[1]);
1408            vs_top=sup;
1409            goto TTL;
1410    TTL:;
1411            if(((V158))!=Cnil){
1412            goto T452;}
1413            base[2]= small_fixnum(0);
1414            vs_top=(vs_base=base+2)+1;
1415            return;
1416            goto T452;
1417    T452:;
1418            {long V160;
1419            base[2]= (V158);
1420            base[3]= (V159);
1421            vs_top=(vs_base=base+2)+2;
1422            (void) (*Lnk77)();
1423            vs_top=sup;
1424            V160= fix(vs_base[0]);
1425            base[2]= make_fixnum(V160);
1426            vs_top=(vs_base=base+2)+1;
1427            return;}
1428            }
1429    }
1430    /*      function definition for DESTRUCTURING-SIZE      */
1431    
1432    static void L37()
1433    {register object *base=vs_base;
1434            register object *sup=base+VM30; VC30
1435            vs_reserve(VM30);
1436            {object V161;
1437            check_arg(1);
1438            V161=(base[0]);
1439            vs_top=sup;
1440            goto TTL;
1441    TTL:;
1442            {register object V162;
1443            register object V163;
1444            V162= (V161);
1445            V163= small_fixnum(0);
1446            goto T458;
1447    T458:;
1448            if(!(type_of((V162))!=t_cons)){
1449            goto T459;}
1450            if(((V162))!=Cnil){
1451            goto T464;}
1452            V164= small_fixnum(0);
1453            goto T462;
1454            goto T464;
1455    T464:;
1456            V164= small_fixnum(1);
1457            goto T462;
1458    T462:;
1459            base[1]= number_plus((V163),V164);
1460            vs_top=(vs_base=base+1)+1;
1461            return;
1462            goto T459;
1463    T459:;
1464            {object V165;
1465            V165= cdr((V162));
1466            base[1]= car((V162));
1467            vs_top=(vs_base=base+1)+1;
1468            (void) (*Lnk341)();
1469            vs_top=sup;
1470            V166= vs_base[0];
1471            V163= number_plus(V166,(V163));
1472            V162= (V165);}
1473            goto T458;}
1474            }
1475    }
1476    /*      function definition for ESTIMATE-CODE-SIZE      */
1477    
1478    static void L38()
1479    {register object *VOL base=vs_base;
1480            register object *VOL sup=base+VM31; VC31
1481            vs_reserve(VM31);
1482            {VOL object V167;
1483            VOL object V168;
1484            check_arg(2);
1485            V167=(base[0]);
1486            V168=(base[1]);
1487            vs_top=sup;
1488            goto TTL;
1489    TTL:;
1490            frs_push(FRS_CATCH,VV[77]);
1491            if(nlj_active)
1492            {nlj_active=FALSE;frs_pop();
1493            return;}
1494            else{
1495            base[2]= (V167);
1496            base[3]= (V168);
1497            vs_top=(vs_base=base+2)+2;
1498            (void) (*Lnk342)();
1499            frs_pop();
1500            return;}
1501            }
1502    }
1503    /*      function definition for ESTIMATE-CODE-SIZE-1    */
1504    
1505    static void L39()
1506    {register object *base=vs_base;
1507            register object *sup=base+VM32; VC32
1508            vs_reserve(VM32);
1509            {object V169;
1510            check_arg(2);
1511            V169=(base[0]);
1512            vs_top=sup;
1513            goto TTL;
1514    TTL:;
1515            base[2]= (V169);
1516            vs_top=(vs_base=base+2)+1;
1517            Lconstantp();
1518            vs_top=sup;
1519            if((vs_base[0])==Cnil){
1520            goto T477;}
1521            base[2]= small_fixnum(1);
1522            vs_top=(vs_base=base+2)+1;
1523            return;
1524            goto T477;
1525    T477:;
1526            if(!(type_of((V169))==t_symbol)){
1527            goto T481;}
1528            {object V170;
1529            object V171;
1530            base[2]= (V169);
1531            base[3]= base[1];
1532            vs_top=(vs_base=base+2)+2;
1533            Lmacroexpand_1();
1534            if(vs_base>=vs_top){vs_top=sup;goto T486;}
1535            V170= vs_base[0];
1536            vs_base++;
1537            if(vs_base>=vs_top){vs_top=sup;goto T487;}
1538            V171= vs_base[0];
1539            vs_top=sup;
1540            goto T488;
1541            goto T486;
1542    T486:;
1543            V170= Cnil;
1544            goto T487;
1545    T487:;
1546            V171= Cnil;
1547            goto T488;
1548    T488:;
1549            if(((V171))==Cnil){
1550            goto T490;}
1551            V169= (V170);
1552            goto TTL;
1553            goto T490;
1554    T490:;
1555            base[2]= small_fixnum(1);
1556            vs_top=(vs_base=base+2)+1;
1557            return;}
1558            goto T481;
1559    T481:;
1560            if(!(type_of((V169))!=t_cons)){
1561            goto T496;}
1562            base[2]= small_fixnum(1);
1563            vs_top=(vs_base=base+2)+1;
1564            return;
1565            goto T496;
1566    T496:;
1567            if(!(type_of(car((V169)))==t_symbol)){
1568            goto T499;}
1569            {object V172;
1570            object V173;
1571            register long V174;
1572            V172= car((V169));
1573            V174= 0;
1574            V173= Cnil;
1575            V173= get((V172),VV[77],Cnil);
1576            if(((V173))==Cnil){
1577            goto T504;}
1578            if(!(type_of(V173)==t_fixnum)){
1579            goto T508;}
1580            base[2]= cdr((V169));
1581            vs_top=(vs_base=base+2)+1;
1582            L40(base);
1583            vs_top=sup;
1584            V176= fix(vs_base[0]);
1585            base[2]= make_fixnum((long)(fix((V173)))+(V176));
1586            vs_top=(vs_base=base+2)+1;
1587            return;
1588            goto T508;
1589    T508:;
1590            base[2]= (V169);
1591            base[3]= base[1];
1592            vs_top=(vs_base=base+2)+2;
1593            super_funcall_no_event((V173));
1594            return;
1595            goto T504;
1596    T504:;
1597            {register object x= (V172),V177= symbol_value(VV[78]);
1598            while(!endp(V177))
1599            if(type_of(V177->c.c_car)==t_cons &&eql(x,V177->c.c_car->c.c_car)){
1600            V173= (V177->c.c_car);
1601            goto T517;
1602            }else V177=V177->c.c_cdr;
1603            V173= Cnil;}
1604            goto T517;
1605    T517:;
1606            if(((V173))==Cnil){
1607            goto T515;}
1608            {long V178= fix(cadr((V173)));
1609            base[2]= cdr((V169));
1610            vs_top=(vs_base=base+2)+1;
1611            L40(base);
1612            vs_top=sup;
1613            V179= fix(vs_base[0]);
1614            base[2]= make_fixnum((long)(/* INLINE-ARGS */V178)+(V179));
1615            vs_top=(vs_base=base+2)+1;
1616            return;}
1617            goto T515;
1618    T515:;
1619            if(!(((V172))==(VV[79]))){
1620            goto T521;}
1621            {register object V180;
1622            object V181;
1623            V180= cdr((V169));
1624            V181= car((V180));
1625            goto T526;
1626    T526:;
1627            if(!(endp_prop((V180)))){
1628            goto T527;}
1629            base[4]= make_fixnum(V174);
1630            vs_top=(vs_base=base+4)+1;
1631            return;
1632            goto T527;
1633    T527:;
1634            V182 = make_fixnum(V174);
1635            base[4]= (V181);
1636            vs_top=(vs_base=base+4)+1;
1637            L40(base);
1638            vs_top=sup;
1639            V183= vs_base[0];
1640            V174= fix(number_plus(V182,V183));
1641            V174= (long)(V174)+(1);
1642            V180= cdr((V180));
1643            V181= car((V180));
1644            goto T526;}
1645            goto T521;
1646    T521:;
1647            if(!(((V172))==(VV[80]))){
1648            goto T543;}
1649            {register object V184;
1650            V184= cdr((V169));
1651            goto T547;
1652    T547:;
1653            if(((V184))!=Cnil){
1654            goto T548;}
1655            base[2]= make_fixnum(V174);
1656            vs_top=(vs_base=base+2)+1;
1657            return;
1658            goto T548;
1659    T548:;
1660            base[2]= make_fixnum(V174);
1661            base[4]= car((V184));
1662            vs_top=(vs_base=base+4)+1;
1663            (void) (*Lnk341)();
1664            vs_top=sup;
1665            base[3]= vs_base[0];
1666            base[5]= cadr((V184));
1667            base[6]= base[1];
1668            vs_top=(vs_base=base+5)+2;
1669            (void) (*Lnk342)();
1670            vs_top=sup;
1671            base[4]= vs_base[0];
1672            vs_top=(vs_base=base+2)+3;
1673            Lplus();
1674            vs_top=sup;
1675            V174= fix(vs_base[0]);
1676            V184= cdr((V184));
1677            goto T547;}
1678            goto T543;
1679    T543:;
1680            {register object x= (V172),V185= VV[81];
1681            while(!endp(V185))
1682            if(eql(x,V185->c.c_car)){
1683            goto T565;
1684            }else V185=V185->c.c_cdr;
1685            goto T564;}
1686            goto T565;
1687    T565:;
1688            {register object V186;
1689            V186= cdr((V169));
1690            goto T568;
1691    T568:;
1692            if(((V186))!=Cnil){
1693            goto T569;}
1694            base[2]= make_fixnum(V174);
1695            vs_top=(vs_base=base+2)+1;
1696            return;
1697            goto T569;
1698    T569:;
1699            base[2]= make_fixnum(V174);
1700            base[4]= cadr((V186));
1701            base[5]= base[1];
1702            vs_top=(vs_base=base+4)+2;
1703            (void) (*Lnk342)();
1704            vs_top=sup;
1705            base[3]= vs_base[0];
1706            base[4]= small_fixnum(1);
1707            vs_top=(vs_base=base+2)+3;
1708            Lplus();
1709            vs_top=sup;
1710            V174= fix(vs_base[0]);
1711            V186= cdr((V186));
1712            goto T568;}
1713            goto T564;
1714    T564:;
1715            if(!(((V172))==(VV[82]))){
1716            goto T584;}
1717            base[2]= small_fixnum(1);
1718            vs_top=(vs_base=base+2)+1;
1719            return;
1720            goto T584;
1721    T584:;
1722            if(!(((V172))==(VV[83]))){
1723            goto T587;}
1724            if(type_of(cadr((V169)))==t_symbol){
1725            goto T589;}
1726            if(!(type_of(cadr((V169)))==t_cons)){
1727            goto T590;}
1728            if(!((caadr((V169)))==(VV[9]))){
1729            goto T590;}
1730            goto T589;
1731    T589:;
1732            base[2]= small_fixnum(1);
1733            vs_top=(vs_base=base+2)+1;
1734            return;
1735            goto T590;
1736    T590:;
1737            {frame_ptr fr;
1738            fr=frs_sch_catch(VV[84]);
1739            if(fr==NULL) FEerror("The tag ~s is undefined.",1,VV[84]);
1740            base[2]= Cnil;
1741            vs_top=(vs_base=base+2)+1;
1742            unwind(fr,VV[84]);}
1743            goto T587;
1744    T587:;
1745            if(!(((V172))==(VV[85]))){
1746            goto T598;}
1747            {long V187= (long)length(cadr((V169)));
1748            base[2]= cddr((V169));
1749            vs_top=(vs_base=base+2)+1;
1750            L40(base);
1751            vs_top=sup;
1752            V188= fix(vs_base[0]);
1753            base[2]= make_fixnum((long)(/* INLINE-ARGS */V187)+(V188));
1754            vs_top=(vs_base=base+2)+1;
1755            return;}
1756            goto T598;
1757    T598:;
1758            if(!(((V172))==(VV[86]))){
1759            goto T603;}
1760            base[2]= caddr((V169));
1761            base[3]= base[1];
1762            vs_top=(vs_base=base+2)+2;
1763            (void) (*Lnk342)();
1764            vs_top=sup;
1765            V189= vs_base[0];
1766            base[2]= one_plus(V189);
1767            vs_top=(vs_base=base+2)+1;
1768            return;
1769            goto T603;
1770    T603:;
1771            base[2]= (V172);
1772            vs_top=(vs_base=base+2)+1;
1773            (void) (*Lnk343)();
1774            vs_top=sup;
1775            if((vs_base[0])!=Cnil){
1776            goto T608;}
1777            {register object x= (V172),V190= symbol_value(VV[87]);
1778            while(!endp(V190))
1779            if(eql(x,V190->c.c_car)){
1780            goto T613;
1781            }else V190=V190->c.c_cdr;
1782            goto T609;}
1783            goto T613;
1784    T613:;
1785            goto T608;
1786    T608:;
1787            {frame_ptr fr;
1788            fr=frs_sch_catch(VV[77]);
1789            if(fr==NULL) FEerror("The tag ~s is undefined.",1,VV[77]);
1790            base[2]= Cnil;
1791            vs_top=(vs_base=base+2)+1;
1792            unwind(fr,VV[77]);}
1793            goto T609;
1794    T609:;
1795            {object V191;
1796            object V192;
1797            base[2]= (V169);
1798            base[3]= base[1];
1799            vs_top=(vs_base=base+2)+2;
1800            Lmacroexpand_1();
1801            if(vs_base>=vs_top){vs_top=sup;goto T618;}
1802            V191= vs_base[0];
1803            vs_base++;
1804            if(vs_base>=vs_top){vs_top=sup;goto T619;}
1805            V192= vs_base[0];
1806            vs_top=sup;
1807            goto T620;
1808            goto T618;
1809    T618:;
1810            V191= Cnil;
1811            goto T619;
1812    T619:;
1813            V192= Cnil;
1814            goto T620;
1815    T620:;
1816            if(((V192))==Cnil){
1817            goto T622;}
1818            V169= (V191);
1819            goto TTL;
1820            goto T622;
1821    T622:;
1822            base[2]= cdr((V169));
1823            vs_top=(vs_base=base+2)+1;
1824            L40(base);
1825            vs_top=sup;
1826            V193= fix(vs_base[0]);
1827            base[2]= make_fixnum((long)(3)+(V193));
1828            vs_top=(vs_base=base+2)+1;
1829            return;}}
1830            goto T499;
1831    T499:;
1832            {frame_ptr fr;
1833            fr=frs_sch_catch(VV[77]);
1834            if(fr==NULL) FEerror("The tag ~s is undefined.",1,VV[77]);
1835            base[2]= Cnil;
1836            vs_top=(vs_base=base+2)+1;
1837            unwind(fr,VV[77]);}
1838            }
1839    }
1840    /*      function definition for LOOP-CONTEXT    */
1841    
1842    static void L41()
1843    {register object *base=vs_base;
1844            register object *sup=base+VM33; VC33
1845            vs_reserve(VM33);
1846            check_arg(0);
1847            vs_top=sup;
1848            goto TTL;
1849    TTL:;
1850            {register object V194;
1851            register object V195;
1852            V194= symbol_value(VV[88]);
1853            V195= Cnil;
1854            goto T631;
1855    T631:;
1856            if(!(((V194))==(cdr(symbol_value(VV[89]))))){
1857            goto T632;}
1858            base[0]= nreverse((V195));
1859            vs_top=(vs_base=base+0)+1;
1860            return;
1861            goto T632;
1862    T632:;
1863            {object V196;
1864            V196= cdr((V194));
1865            V195= make_cons(car((V194)),(V195));
1866            V194= (V196);}
1867            goto T631;}
1868    }
1869    /*      function definition for LOOP-ERROR      */
1870    
1871    static void L42()
1872    {register object *base=vs_base;
1873            register object *sup=base+VM34; VC34
1874            vs_reserve(VM34);
1875            {object V197;
1876            object V198;
1877            if(vs_top-vs_base<1) too_few_arguments();
1878            V197=(base[0]);
1879            vs_base=vs_base+1;
1880            vs_top[0]=Cnil;
1881            {object *p=vs_top;
1882             for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);}
1883            V198=(base[1]);
1884            vs_top=sup;
1885            base[2]= VV[90];
1886            base[3]= VV[91];
1887            base[4]= (V197);
1888            base[5]= (V198);
1889            vs_base=vs_top;
1890            (void) (*Lnk344)();
1891            vs_top=sup;
1892            base[6]= vs_base[0];
1893            vs_top=(vs_base=base+2)+5;
1894            (void) (*Lnk345)();
1895            return;
1896            }
1897    }
1898    /*      function definition for LOOP-WARN       */
1899    
1900    static void L43()
1901    {register object *base=vs_base;
1902            register object *sup=base+VM35; VC35
1903            vs_reserve(VM35);
1904            {object V199;
1905            object V200;
1906            if(vs_top-vs_base<1) too_few_arguments();
1907            V199=(base[0]);
1908            vs_base=vs_base+1;
1909            vs_top[0]=Cnil;
1910            {object *p=vs_top;
1911             for(;p>vs_base;p--)p[-1]=MMcons(p[-1],p[0]);}
1912            V200=(base[1]);
1913            vs_top=sup;
1914            vs_base=vs_top;
1915            (void) (*Lnk344)();
1916            vs_top=sup;
1917            V201= vs_base[0];
1918            base[2]= (VFUN_NARGS=4,(*(LnkLI346))(VV[92],(V199),(V200),V201));
1919            vs_top=(vs_base=base+2)+1;
1920            return;
1921            }
1922    }
1923    /*      function definition for LOOP-CHECK-DATA-TYPE    */
1924    
1925    static void L44()
1926    {register object *base=vs_base;
1927            register object *sup=base+VM36; VC36
1928            vs_reserve(VM36);
1929            {register object V202;
1930            register object V203;
1931            object V204;
1932            if(vs_top-vs_base<2) too_few_arguments();
1933            if(vs_top-vs_base>3) too_many_arguments();
1934            V202=(base[0]);
1935            V203=(base[1]);
1936            vs_base=vs_base+2;
1937            if(vs_base>=vs_top){vs_top=sup;goto T646;}
1938            V204=(base[2]);
1939            vs_top=sup;
1940            goto T647;
1941            goto T646;
1942    T646:;
1943            V204= (V203);
1944            goto T647;
1945    T647:;
1946            if(((V202))!=Cnil){
1947            goto T650;}
1948            base[3]= (V204);
1949            vs_top=(vs_base=base+3)+1;
1950            return;
1951            goto T650;
1952    T650:;
1953            {object V205;
1954            object V206;
1955            base[3]= (V202);
1956            base[4]= (V203);
1957            vs_top=(vs_base=base+3)+2;
1958            (void) (*Lnk326)();
1959            if(vs_base>=vs_top){vs_top=sup;goto T655;}
1960            V205= vs_base[0];
1961            vs_base++;
1962            if(vs_base>=vs_top){vs_top=sup;goto T656;}
1963            V206= vs_base[0];
1964            vs_top=sup;
1965            goto T657;
1966            goto T655;
1967    T655:;
1968            V205= Cnil;
1969            goto T656;
1970    T656:;
1971            V206= Cnil;
1972            goto T657;
1973    T657:;
1974            if(((V206))!=Cnil){
1975            goto T660;}
1976            base[3]= VV[93];
1977            base[4]= (V202);
1978            base[5]= (V203);
1979            vs_top=(vs_base=base+3)+3;
1980            (void) (*Lnk338)();
1981            vs_top=sup;
1982            goto T658;
1983            goto T660;
1984    T660:;
1985            if(((V205))!=Cnil){
1986            goto T658;}
1987            base[3]= VV[94];
1988            base[4]= (V202);
1989            base[5]= (V203);
1990            vs_top=(vs_base=base+3)+3;
1991            (void) (*Lnk347)();
1992            vs_top=sup;
1993            goto T658;
1994    T658:;
1995            base[3]= (V202);
1996            vs_top=(vs_base=base+3)+1;
1997            return;}
1998            }
1999    }
2000    /*      macro definition for LOOP-FINISH        */
2001    
2002    static void L45()
2003    {register object *base=vs_base;
2004            register object *sup=base+VM37; VC37
2005            vs_reserve(VM37);
2006            check_arg(2);
2007            vs_top=sup;
2008            {object V207=base[0]->c.c_cdr;
2009            if(!endp(V207))invalid_macro_call();}
2010            base[2]= VV[95];
2011            vs_top=(vs_base=base+2)+1;
2012            return;
2013    }
2014    /*      function definition for LOOP-TRANSLATE  */
2015    
2016    static void L46()
2017    {register object *base=vs_base;
2018            register object *sup=base+VM38; VC38
2019            vs_reserve(VM38);
2020            bds_check;
2021            check_arg(3);
2022            bds_bind(VV[89],base[0]);
2023            bds_bind(VV[96],base[1]);
2024            bds_bind(VV[97],base[2]);
2025            vs_top=sup;
2026            goto TTL;
2027    TTL:;
2028            bds_bind(VV[98],(VV[89]->s.s_dbind));
2029            bds_bind(VV[88],Cnil);
2030            bds_bind(VV[99],Cnil);
2031            bds_bind(VV[100],Cnil);
2032            bds_bind(VV[101],Cnil);
2033            bds_bind(VV[102],Cnil);
2034            bds_bind(VV[103],Cnil);
2035            bds_bind(VV[104],Cnil);
2036            bds_bind(VV[105],Cnil);
2037            bds_bind(VV[106],Cnil);
2038            bds_bind(VV[107],Cnil);
2039            bds_bind(VV[108],Cnil);
2040            bds_bind(VV[109],Cnil);
2041            bds_bind(VV[110],Cnil);
2042            bds_bind(VV[111],Cnil);
2043            bds_bind(VV[112],Cnil);
2044            bds_bind(VV[113],Cnil);
2045            bds_bind(VV[114],Cnil);
2046            bds_bind(VV[115],Cnil);
2047            bds_bind(VV[116],Cnil);
2048            bds_bind(VV[117],Cnil);
2049            bds_bind(VV[118],Cnil);
2050            bds_bind(VV[119],Cnil);
2051            bds_bind(VV[120],Cnil);
2052            vs_base=vs_top;
2053            (void) (*Lnk348)();
2054            vs_top=sup;
2055            vs_base=vs_top;
2056            (void) (*Lnk349)();
2057            vs_top=sup;
2058            {register object V208;
2059            V209= nreverse((VV[106]->s.s_dbind));
2060            V210= nreverse((VV[108]->s.s_dbind));
2061            V211= nreverse((VV[109]->s.s_dbind));
2062            V212= nreverse((VV[111]->s.s_dbind));
2063            base[27]= (VV[112]->s.s_dbind);
2064            base[28]= nreverse((VV[113]->s.s_dbind));
2065            vs_top=(vs_base=base+27)+2;
2066            Lreconc();
2067            vs_top=sup;
2068            V213= vs_base[0];
2069            V208= list(6,VV[121],/* INLINE-ARGS */V209,/* INLINE-ARGS */V210,/* INLINE-ARGS */V211,/* INLINE-ARGS */V212,V213);
2070            {register object V214;
2071            register object V215;
2072            V214= (VV[105]->s.s_dbind);
2073            V215= car((V214));
2074            goto T680;
2075    T680:;
2076            if(!(endp_prop((V214)))){
2077            goto T681;}
2078            goto T676;
2079            goto T681;
2080    T681:;
2081            {object V216;
2082            object V217;
2083            object V218;
2084            object V219;
2085            V216= car((V215));
2086            V217= cadr((V215));
2087            V218= caddr((V215));
2088            V219= cadddr((V215));
2089            {register object V220;
2090            register object V221;
2091            V220= (V219);
2092            V221= car((V220));
2093            goto T694;
2094    T694:;
2095            if(!(endp_prop((V220)))){
2096            goto T695;}
2097            goto T690;
2098            goto T695;
2099    T695:;
2100            V222= make_cons((V208),Cnil);
2101            V208= append((V221),/* INLINE-ARGS */V222);
2102            V220= cdr((V220));
2103            V221= car((V220));
2104            goto T694;}
2105            goto T690;
2106    T690:;
2107            if(((V216))!=Cnil){
2108            goto T706;}
2109            if(((V217))!=Cnil){
2110            goto T706;}
2111            if(((V218))==Cnil){
2112            goto T685;}
2113            goto T706;
2114    T706:;
2115            {register object V223;
2116            V223= make_cons((V208),Cnil);
2117            if(((V217))==Cnil){
2118            goto T713;}
2119            {object V224;
2120            V224= make_cons(VV[30],(V217));
2121            V223= make_cons((V224),(V223));}
2122            goto T713;
2123    T713:;
2124            if(((V216))!=Cnil){
2125            goto T721;}
2126            V225= VV[122];
2127            goto T719;
2128            goto T721;
2129    T721:;
2130            if((symbol_value(VV[63]))==Cnil){
2131            goto T724;}
2132            V225= car(symbol_value(VV[63]));
2133            goto T719;
2134            goto T724;
2135    T724:;
2136            V225= VV[29];
2137            goto T719;
2138    T719:;
2139            if(((V218))==Cnil){
2140            goto T728;}
2141            V227= append((V218),(V223));
2142            V228= make_cons(VV[123],/* INLINE-ARGS */V227);
2143            V226= make_cons(/* INLINE-ARGS */V228,Cnil);
2144            goto T726;
2145            goto T728;
2146    T728:;
2147            V226= (V223);
2148            goto T726;
2149    T726:;
2150            V208= listA(3,V225,(V216),V226);}}
2151            goto T685;
2152    T685:;
2153            V214= cdr((V214));
2154            V215= car((V214));
2155            goto T680;}
2156            goto T676;
2157    T676:;
2158            V208= list(3,VV[124],car((VV[118]->s.s_dbind)),(V208));
2159            base[27]= (V208);
2160            vs_top=(vs_base=base+27)+1;
2161            bds_unwind1;
2162            bds_unwind1;
2163            bds_unwind1;
2164            bds_unwind1;
2165            bds_unwind1;
2166            bds_unwind1;
2167            bds_unwind1;
2168            bds_unwind1;
2169            bds_unwind1;
2170            bds_unwind1;
2171            bds_unwind1;
2172            bds_unwind1;
2173            bds_unwind1;
2174            bds_unwind1;
2175            bds_unwind1;
2176            bds_unwind1;
2177            bds_unwind1;
2178            bds_unwind1;
2179            bds_unwind1;
2180            bds_unwind1;
2181            bds_unwind1;
2182            bds_unwind1;
2183            bds_unwind1;
2184            bds_unwind1;
2185            bds_unwind1;
2186            bds_unwind1;
2187            bds_unwind1;
2188            return;}
2189    }
2190    /*      function definition for LOOP-ITERATION-DRIVER   */
2191    
2192    static void L47()
2193    {register object *base=vs_base;
2194            register object *sup=base+VM39; VC39
2195            vs_reserve(VM39);
2196            check_arg(0);
2197            vs_top=sup;
2198            goto TTL;
2199    TTL:;
2200            goto T738;
2201    T738:;
2202            if((symbol_value(VV[89]))!=Cnil){
2203            goto T739;}
2204            base[0]= Cnil;
2205            vs_top=(vs_base=base+0)+1;
2206            return;
2207            goto T739;
2208    T739:;
2209            {register object V229;
2210            register object V230;
2211            V229= car(symbol_value(VV[89]));
2212            V230= Cnil;
2213            if(type_of((V229))==t_symbol){
2214            goto T746;}
2215            base[0]= VV[125];
2216            base[1]= (V229);
2217            vs_top=(vs_base=base+0)+2;
2218            (void) (*Lnk347)();
2219            vs_top=sup;
2220            goto T743;
2221            goto T746;
2222    T746:;
2223            setq(VV[88],symbol_value(VV[89]));
2224            vs_base=vs_top;
2225            (void) (*Lnk350)();
2226            vs_top=sup;
2227            base[0]= (V229);
2228            base[1]= structure_ref(symbol_value(VV[97]),VV[39],0);
2229            vs_top=(vs_base=base+0)+2;
2230            (void) (*Lnk351)();
2231            vs_top=sup;
2232            V230= vs_base[0];
2233            if(((V230))==Cnil){
2234            goto T754;}
2235            base[1]= car((V230));
2236            vs_top=(vs_base=base+1)+1;
2237            Lsymbol_function();
2238            vs_top=sup;
2239            base[0]= vs_base[0];
2240            {object V231;
2241            V231= cdr((V230));
2242             vs_top=base+1;
2243             while(!endp(V231))
2244             {vs_push(car(V231));V231=cdr(V231);}
2245            vs_base=base+1;}
2246            super_funcall_no_event(base[0]);
2247            vs_top=sup;
2248            goto T743;
2249            goto T754;
2250    T754:;
2251            base[0]= (V229);
2252            base[1]= structure_ref(symbol_value(VV[97]),VV[39],1);
2253            vs_top=(vs_base=base+0)+2;
2254            (void) (*Lnk351)();
2255            vs_top=sup;
2256            V230= vs_base[0];
2257            if(((V230))==Cnil){
2258            goto T763;}
2259            base[0]= (V230);
2260            vs_top=(vs_base=base+0)+1;
2261            (void) (*Lnk352)();
2262            vs_top=sup;
2263            goto T743;
2264            goto T763;
2265    T763:;
2266            base[0]= (V229);
2267            base[1]= VV[126];
2268            vs_top=(vs_base=base+0)+2;
2269            (void) (*Lnk353)();
2270            vs_top=sup;
2271            if((vs_base[0])==Cnil){
2272            goto T770;}
2273            base[0]= VV[127];
2274            base[1]= (V229);
2275            base[2]= car(symbol_value(VV[89]));
2276            base[3]= cadr(symbol_value(VV[89]));
2277            vs_top=(vs_base=base+0)+4;
2278            (void) (*Lnk347)();
2279            vs_top=sup;
2280            goto T743;
2281            goto T770;
2282    T770:;
2283            base[0]= VV[128];
2284            base[1]= (V229);
2285            vs_top=(vs_base=base+0)+2;
2286            (void) (*Lnk347)();
2287            vs_top=sup;}
2288            goto T743;
2289    T743:;
2290            goto T738;
2291    }
2292    /*      function definition for LOOP-POP-SOURCE */
2293    
2294    static void L48()
2295    {register object *base=vs_base;
2296            register object *sup=base+VM40; VC40
2297            vs_reserve(VM40);
2298            check_arg(0);
2299            vs_top=sup;
2300            goto TTL;
2301    TTL:;
2302            if((symbol_value(VV[89]))==Cnil){
2303            goto T783;}
2304            {object V232;
2305            V232= car(symbol_value(VV[89]));
2306            setq(VV[89],cdr(symbol_value(VV[89])));
2307            base[0]= (V232);
2308            vs_top=(vs_base=base+0)+1;
2309            return;}
2310            goto T783;
2311    T783:;
2312            base[0]= VV[129];
2313            vs_top=(vs_base=base+0)+1;
2314            (void) (*Lnk347)();
2315            return;
2316    }
2317    /*      function definition for LOOP-GET-PROGN  */
2318    
2319    static void L49()
2320    {register object *base=vs_base;
2321            register object *sup=base+VM41; VC41
2322            vs_reserve(VM41);
2323            check_arg(0);
2324            vs_top=sup;
2325            goto TTL;
2326    TTL:;
2327            {register object V233;
2328            register object V234;
2329            vs_base=vs_top;
2330            (void) (*Lnk350)();
2331            vs_top=sup;
2332            V235= vs_base[0];
2333            V233= make_cons(V235,Cnil);
2334            V234= car(symbol_value(VV[89]));
2335            goto T793;
2336    T793:;
2337            if(!(type_of((V234))!=t_cons)){
2338            goto T794;}
2339            if((cdr((V233)))!=Cnil){
2340            goto T798;}
2341            base[0]= car((V233));
2342            vs_top=(vs_base=base+0)+1;
2343            return;
2344            goto T798;
2345    T798:;
2346            V236= nreverse((V233));
2347            base[0]= make_cons(VV[14],/* INLINE-ARGS */V236);
2348            vs_top=(vs_base=base+0)+1;
2349            return;
2350            goto T794;
2351    T794:;
2352            vs_base=vs_top;
2353            (void) (*Lnk350)();
2354            vs_top=sup;
2355            V237= vs_base[0];
2356            V233= make_cons(V237,(V233));
2357            V234= car(symbol_value(VV[89]));
2358            goto T793;}
2359    }
2360    /*      function definition for LOOP-GET-FORM   */
2361    
2362    static void L50()
2363    {register object *base=vs_base;
2364            register object *sup=base+VM42; VC42
2365            vs_reserve(VM42);
2366            check_arg(0);
2367            vs_top=sup;
2368            goto TTL;
2369    TTL:;
2370            if((symbol_value(VV[89]))==Cnil){
2371            goto T807;}
2372            vs_base=vs_top;
2373            (void) (*Lnk350)();
2374            return;
2375            goto T807;
2376    T807:;
2377            base[0]= VV[130];
2378            vs_top=(vs_base=base+0)+1;
2379            (void) (*Lnk347)();
2380            return;
2381    }
2382    /*      function definition for LOOP-CONSTRUCT-RETURN   */
2383    
2384    static void L51()
2385    {register object *base=vs_base;
2386            register object *sup=base+VM43; VC43
2387            vs_reserve(VM43);
2388            {object V238;
2389            check_arg(1);
2390            V238=(base[0]);
2391            vs_top=sup;
2392            goto TTL;
2393    TTL:;
2394            base[1]= list(3,VV[86],car(symbol_value(VV[118])),(V238));
2395            vs_top=(vs_base=base+1)+1;
2396            return;
2397            }
2398    }
2399    /*      function definition for LOOP-PSEUDO-BODY        */
2400    
2401    static void L52()
2402    {register object *base=vs_base;
2403            register object *sup=base+VM44; VC44
2404            vs_reserve(VM44);
2405            {object V239;
2406            check_arg(1);
2407            V239=(base[0]);
2408            vs_top=sup;
2409            goto TTL;
2410    TTL:;
2411            if((symbol_value(VV[110]))!=Cnil){
2412            goto T810;}
2413            if((symbol_value(VV[115]))==Cnil){
2414            goto T811;}
2415            goto T810;
2416    T810:;
2417            setq(VV[109],make_cons(V239,symbol_value(VV[109])));
2418            base[1]= symbol_value(VV[109]);
2419            vs_top=(vs_base=base+1)+1;
2420            return;
2421            goto T811;
2422    T811:;
2423            setq(VV[108],make_cons(V239,symbol_value(VV[108])));
2424            setq(VV[111],make_cons(V239,symbol_value(VV[111])));
2425            base[1]= symbol_value(VV[111]);
2426            vs_top=(vs_base=base+1)+1;
2427            return;
2428            }
2429    }
2430    /*      function definition for LOOP-EMIT-BODY  */
2431    
2432    static void L53()
2433    {register object *base=vs_base;
2434            register object *sup=base+VM45; VC45
2435            vs_reserve(VM45);
2436            {object V243;
2437            check_arg(1);
2438            V243=(base[0]);
2439            vs_top=sup;
2440            goto TTL;
2441    TTL:;
2442            setq(VV[110],Ct);
2443            base[1]= (V243);
2444            vs_top=(vs_base=base+1)+1;
2445            (void) (*Lnk354)();
2446            return;
2447            }
2448    }
2449    /*      function definition for LOOP-EMIT-FINAL-VALUE   */
2450    
2451    static void L54()
2452    {register object *base=vs_base;
2453            register object *sup=base+VM46; VC46
2454            vs_reserve(VM46);
2455            {object V244;
2456            check_arg(1);
2457            V244=(base[0]);
2458            vs_top=sup;
2459            goto TTL;
2460    TTL:;
2461            {object V245;
2462            base[2]= (V244);
2463            vs_top=(vs_base=base+2)+1;
2464            (void) (*Lnk355)();
2465            vs_top=sup;
2466            V245= vs_base[0];
2467            setq(VV[113],make_cons((V245),symbol_value(VV[113])));}
2468            if((symbol_value(VV[114]))==Cnil){
2469            goto T826;}
2470            if((symbol_value(VV[119]))==Cnil){
2471            goto T830;}
2472            base[1]= VV[90];
2473            base[2]= VV[131];
2474            base[3]= symbol_value(VV[114]);
2475            vs_top=(vs_base=base+1)+3;
2476            (void) (*Lnk345)();
2477            vs_top=sup;
2478            goto T826;
2479            goto T830;
2480    T830:;
2481            base[1]= VV[132];
2482            base[2]= symbol_value(VV[114]);
2483            vs_top=(vs_base=base+1)+2;
2484            (void) (*Lnk338)();
2485            vs_top=sup;
2486            goto T826;
2487    T826:;
2488            setq(VV[114],car(symbol_value(VV[88])));
2489            base[1]= symbol_value(VV[114]);
2490            vs_top=(vs_base=base+1)+1;
2491            return;
2492            }
2493    }
2494    /*      function definition for LOOP-DISALLOW-CONDITIONAL       */
2495    
2496    static void L55()
2497    {register object *base=vs_base;
2498            register object *sup=base+VM47; VC47
2499            vs_reserve(VM47);
2500            {object V246;
2501            if(vs_top-vs_base>1) too_many_arguments();
2502            if(vs_base>=vs_top){vs_top=sup;goto T838;}
2503            V246=(base[0]);
2504            vs_top=sup;
2505            goto T839;
2506            goto T838;
2507    T838:;
2508            V246= Cnil;
2509            goto T839;
2510    T839:;
2511            if((symbol_value(VV[115]))==Cnil){
2512            goto T842;}
2513            base[1]= VV[133];
2514            base[2]= (V246);
2515            vs_top=(vs_base=base+1)+2;
2516            (void) (*Lnk347)();
2517            return;
2518            goto T842;
2519    T842:;
2520            base[1]= Cnil;
2521            vs_top=(vs_base=base+1)+1;
2522            return;
2523            }
2524    }
2525    /*      function definition for LOOP-TYPED-INIT */
2526    
2527    static void L56()
2528    {register object *base=vs_base;
2529            register object *sup=base+VM48; VC48
2530            vs_reserve(VM48);
2531            {register object V247;
2532            check_arg(1);
2533            V247=(base[0]);
2534            vs_top=sup;
2535            goto TTL;
2536    TTL:;
2537            if(((V247))==Cnil){
2538            goto T847;}
2539            base[1]= (V247);
2540            base[2]= VV[134];
2541            vs_top=(vs_base=base+1)+2;
2542            (void) (*Lnk326)();
2543            vs_top=sup;
2544            if((vs_base[0])==Cnil){
2545            goto T847;}
2546            base[1]= (V247);
2547            base[2]= VV[135];
2548            vs_top=(vs_base=base+1)+2;
2549            (void) (*Lnk326)();
2550            vs_top=sup;
2551            if((vs_base[0])!=Cnil){
2552            goto T853;}
2553            base[1]= (V247);
2554            base[2]= VV[136];
2555            vs_top=(vs_base=base+1)+2;
2556            (void) (*Lnk326)();
2557            vs_top=sup;
2558            if((vs_base[0])==Cnil){
2559            goto T854;}
2560            goto T853;
2561    T853:;
2562            base[1]= (*(LnkLI356))(small_fixnum(0),(V247));
2563            vs_top=(vs_base=base+1)+1;
2564            return;
2565            goto T854;
2566    T854:;
2567            base[1]= small_fixnum(0);
2568            vs_top=(vs_base=base+1)+1;
2569            return;
2570            goto T847;
2571    T847:;
2572            base[1]= Cnil;
2573            vs_top=(vs_base=base+1)+1;
2574            return;
2575            }
2576    }
2577    /*      function definition for LOOP-OPTIONAL-TYPE      */
2578    
2579    static void L57()
2580    {register object *base=vs_base;
2581            register object *sup=base+VM49; VC49
2582            vs_reserve(VM49);
2583            if(vs_top-vs_base>1) too_many_arguments();
2584            if(vs_base>=vs_top){vs_top=sup;goto T862;}
2585            vs_top=sup;
2586            goto T863;
2587            goto T862;
2588    T862:;
2589            base[0]= Cnil;
2590            goto T863;
2591    T863:;
2592            if(symbol_value(VV[89])==Cnil){
2593            base[1]= Cnil;
2594            vs_top=(vs_base=base+1)+1;
2595            return;}
2596            base[1]= car(symbol_value(VV[89]));
2597            base[2]= base[1];
2598            base[3]= VV[137];
2599            vs_top=(vs_base=base+2)+2;
2600            (void) (*Lnk357)();
2601            vs_top=sup;
2602            if((vs_base[0])==Cnil){
2603            goto T867;}
2604            vs_base=vs_top;
2605            (void) (*Lnk350)();
2606            vs_top=sup;
2607            vs_base=vs_top;
2608            (void) (*Lnk350)();
2609            return;
2610            goto T867;
2611    T867:;
2612            if(!(type_of(base[1])==t_symbol)){
2613            goto T873;}
2614            {object V248;{object V249;
2615            base[2]= base[1];
2616            base[3]= structure_ref(symbol_value(VV[97]),VV[39],4);
2617            vs_top=(vs_base=base+2)+2;
2618            Lgethash();
2619            vs_top=sup;
2620            V249= vs_base[0];
2621            if(V249==Cnil)goto T876;
2622            V248= V249;
2623            goto T875;
2624            goto T876;
2625    T876:;}
2626            base[2]= symbol_name(base[1]);
2627            base[3]= structure_ref(symbol_value(VV[97]),VV[39],5);
2628            vs_top=(vs_base=base+2)+2;
2629            Lgethash();
2630            vs_top=sup;
2631            V248= vs_base[0];
2632            goto T875;
2633    T875:;
2634            if(((V248))==Cnil){
2635            goto T883;}
2636            vs_base=vs_top;
2637            (void) (*Lnk350)();
2638            vs_top=sup;
2639            base[2]= (V248);
2640            vs_top=(vs_base=base+2)+1;
2641            return;
2642            goto T883;
2643    T883:;
2644            base[2]= Cnil;
2645            vs_top=(vs_base=base+2)+1;
2646            return;}
2647            goto T873;
2648    T873:;
2649            if(!(type_of(base[0])==t_cons)){
2650            goto T888;}
2651            if(type_of(base[1])==t_cons){
2652            goto T886;}
2653            base[2]= VV[138];
2654            base[3]= base[1];
2655            vs_top=(vs_base=base+2)+2;
2656            (void) (*Lnk347)();
2657            vs_top=sup;
2658            goto T886;
2659            goto T888;
2660    T888:;
2661            base[2]= VV[139];
2662            base[3]= base[1];
2663            vs_top=(vs_base=base+2)+2;
2664            (void) (*Lnk347)();
2665            vs_top=sup;
2666            goto T886;
2667    T886:;
2668            vs_base=vs_top;
2669            (void) (*Lnk350)();
2670            vs_top=sup;
2671            base[2]= base[1];
2672            base[3]= base[0];
2673            vs_top=(vs_base=base+2)+2;
2674            L58(base);
2675            return;
2676    }
2677    /*      function definition for LOOP-BIND-BLOCK */
2678    
2679    static void L60()
2680    {register object *base=vs_base;
2681            register object *sup=base+VM50; VC50
2682            vs_reserve(VM50);
2683            check_arg(0);
2684            vs_top=sup;
2685            goto TTL;
2686    TTL:;
2687            if((symbol_value(VV[100]))!=Cnil){
2688            goto T899;}
2689            if((symbol_value(VV[103]))!=Cnil){
2690            goto T899;}
2691            if((symbol_value(VV[107]))==Cnil){
2692            goto T900;}
2693            goto T899;
2694    T899:;
2695            {object V250;
2696            V251= nreverse(symbol_value(VV[100]));
2697            V250= list(4,/* INLINE-ARGS */V251,symbol_value(VV[103]),symbol_value(VV[104]),symbol_value(VV[107]));
2698            setq(VV[105],make_cons((V250),symbol_value(VV[105])));}
2699            setq(VV[100],Cnil);
2700            setq(VV[103],Cnil);
2701            setq(VV[104],Cnil);
2702            setq(VV[107],Cnil);
2703            base[0]= Cnil;
2704            vs_top=(vs_base=base+0)+1;
2705            return;
2706            goto T900;
2707    T900:;
2708            base[0]= Cnil;
2709            vs_top=(vs_base=base+0)+1;
2710            return;
2711    }
2712    /*      function definition for LOOP-MAKE-VARIABLE      */
2713    
2714    static void L61()
2715    {register object *base=vs_base;
2716            register object *sup=base+VM51; VC51
2717            vs_reserve(VM51);
2718            {register object V252;
2719            register object V253;
2720            register object V254;
2721            object V255;
2722            if(vs_top-vs_base<3) too_few_arguments();
2723            if(vs_top-vs_base>4) too_many_arguments();
2724            V252=(base[0]);
2725            V253=(base[1]);
2726            V254=(base[2]);
2727            vs_base=vs_base+3;
2728            if(vs_base>=vs_top){vs_top=sup;goto T916;}
2729            V255=(base[3]);
2730            vs_top=sup;
2731            goto T917;
2732            goto T916;
2733    T916:;
2734            V255= Cnil;
2735            goto T917;
2736    T917:;
2737            if(((V252))!=Cnil){
2738            goto T921;}
2739            if(((V253))==Cnil){
2740            goto T919;}
2741            {object V256;
2742            base[5]= VV[142];
2743            vs_top=(vs_base=base+5)+1;
2744            (void) (*Lnk327)();
2745            vs_top=sup;
2746            V252= vs_base[0];
2747            V256= list(2,(V252),(V253));
2748            setq(VV[100],make_cons((V256),symbol_value(VV[100])));}
2749            {object V257;
2750            V257= list(2,VV[143],(V252));
2751            setq(VV[103],make_cons((V257),symbol_value(VV[103])));
2752            goto T919;}
2753            goto T921;
2754    T921:;
2755            if(!(type_of((V252))!=t_cons)){
2756            goto T933;}
2757            if(((V255))==Cnil){
2758            goto T937;}
2759            {register object x= (V252),V258= symbol_value(VV[99]);
2760            while(!endp(V258))
2761            if(eql(x,V258->c.c_car)){
2762            goto T941;
2763            }else V258=V258->c.c_cdr;
2764            goto T940;}
2765            goto T941;
2766    T941:;
2767            base[4]= VV[144];
2768            base[5]= (V252);
2769            vs_top=(vs_base=base+4)+2;
2770            (void) (*Lnk347)();
2771            vs_top=sup;
2772            goto T935;
2773            goto T940;
2774    T940:;
2775            setq(VV[99],make_cons(V252,symbol_value(VV[99])));
2776            goto T935;
2777            goto T937;
2778    T937:;
2779            {register object x= (V252),V260= symbol_value(VV[100]);
2780            while(!endp(V260))
2781            if(type_of(V260->c.c_car)==t_cons &&eql(x,V260->c.c_car->c.c_car)){
2782            goto T946;
2783            }else V260=V260->c.c_cdr;
2784            goto T935;}
2785            goto T946;
2786    T946:;
2787            base[4]= VV[145];
2788            base[5]= (V252);
2789            vs_top=(vs_base=base+4)+2;
2790            (void) (*Lnk347)();
2791            vs_top=sup;
2792            goto T935;
2793    T935:;
2794            if(type_of((V252))==t_symbol){
2795            goto T949;}
2796            base[4]= VV[146];
2797            base[5]= (V252);
2798            vs_top=(vs_base=base+4)+2;
2799            (void) (*Lnk347)();
2800            vs_top=sup;
2801            goto T949;
2802    T949:;
2803            base[4]= (V252);
2804            base[5]= (V254);
2805            vs_top=(vs_base=base+4)+2;
2806            (void) (*Lnk358)();
2807            vs_top=sup;
2808            {object V261;
2809            if((V253)!=Cnil){
2810            V262= (V253);
2811            goto T958;}
2812            base[5]= (V254);
2813            vs_top=(vs_base=base+5)+1;
2814            (void) (*Lnk329)();
2815            vs_top=sup;
2816            V262= vs_base[0];
2817            goto T958;
2818    T958:;
2819            V261= list(2,(V252),V262);
2820            setq(VV[100],make_cons((V261),symbol_value(VV[100])));
2821            goto T919;}
2822            goto T933;
2823    T933:;
2824            if(((V253))==Cnil){
2825            goto T962;}
2826            if((symbol_value(VV[63]))==Cnil){
2827            goto T965;}
2828            base[4]= (V252);
2829            base[5]= (V254);
2830            vs_top=(vs_base=base+4)+2;
2831            (void) (*Lnk358)();
2832            vs_top=sup;
2833            {object V263;
2834            V263= list(2,(V252),(V253));
2835            setq(VV[100],make_cons((V263),symbol_value(VV[100])));
2836            goto T919;}
2837            goto T965;
2838    T965:;
2839            {object V264;
2840            base[4]= VV[147];
2841            vs_top=(vs_base=base+4)+1;
2842            (void) (*Lnk327)();
2843            vs_top=sup;
2844            V264= vs_base[0];
2845            {object V265;
2846            V265= list(2,(V264),(V253));
2847            setq(VV[100],make_cons((V265),symbol_value(VV[100])));}
2848            setq(VV[104],listA(3,(V252),(V264),symbol_value(VV[104])));
2849            goto T919;}
2850            goto T962;
2851    T962:;
2852            {object V266;
2853            object V267;
2854            V266= Cnil;
2855            V267= Cnil;
2856            if(!(type_of((V254))!=t_cons)){
2857            goto T980;}
2858            V267= (V254);
2859            V266= (V267);
2860            goto T978;
2861            goto T980;
2862    T980:;
2863            V266= car((V254));
2864            V267= cdr((V254));
2865            goto T978;
2866    T978:;
2867            base[4]= car((V252));
2868            base[5]= Cnil;
2869            base[6]= (V266);
2870            base[7]= (V255);
2871            vs_top=(vs_base=base+4)+4;
2872            (void) (*Lnk359)();
2873            vs_top=sup;
2874            base[4]= cdr((V252));
2875            base[5]= Cnil;
2876            base[6]= (V267);
2877            base[7]= (V255);
2878            vs_top=(vs_base=base+4)+4;
2879            (void) (*Lnk359)();
2880            vs_top=sup;}
2881            goto T919;
2882    T919:;
2883            base[4]= (V252);
2884            vs_top=(vs_base=base+4)+1;
2885            return;
2886            }
2887    }
2888    /*      function definition for LOOP-MAKE-ITERATION-VARIABLE    */
2889    
2890    static void L62()
2891    {register object *base=vs_base;
2892            register object *sup=base+VM52; VC52
2893            vs_reserve(VM52);
2894            {object V268;
2895            object V269;
2896            object V270;
2897            check_arg(3);
2898            V268=(base[0]);
2899            V269=(base[1]);
2900            V270=(base[2]);
2901            vs_top=sup;
2902            goto TTL;
2903    TTL:;
2904            base[3]= (V268);
2905            base[4]= (V269);
2906            base[5]= (V270);
2907            base[6]= Ct;
2908            vs_top=(vs_base=base+3)+4;
2909            (void) (*Lnk359)();
2910            return;
2911            }
2912    }
2913    /*      function definition for LOOP-DECLARE-VARIABLE   */
2914    
2915    static void L63()
2916    {register object *base=vs_base;
2917            register object *sup=base+VM53; VC53
2918            vs_reserve(VM53);
2919            {register object V271;
2920            register object V272;
2921            check_arg(2);
2922            V271=(base[0]);
2923            V272=(base[1]);
2924            vs_top=sup;
2925            goto TTL;
2926    TTL:;
2927            if(((V271))==Cnil){
2928            goto T1000;}
2929            if(((V272))==Cnil){
2930            goto T1000;}
2931            if(!(((V272))==(Ct))){
2932            goto T1001;}
2933            goto T1000;
2934    T1000:;
2935            base[2]= Cnil;
2936            vs_top=(vs_base=base+2)+1;
2937            return;
2938            goto T1001;
2939    T1001:;
2940            if(!(type_of((V271))==t_symbol)){
2941            goto T1008;}
2942            if(((V272))==(Ct)){
2943            goto T1011;}
2944            {register object x= (V271),V273= symbol_value(VV[101]);
2945            while(!endp(V273))
2946            if(eql(x,V273->c.c_car)){
2947            goto T1011;
2948            }else V273=V273->c.c_cdr;}
2949            {object V275;
2950            V275= list(3,VV[31],V272,(V271));
2951            setq(VV[103],make_cons((V275),symbol_value(VV[103])));
2952            base[3]= symbol_value(VV[103]);
2953            vs_top=(vs_base=base+3)+1;
2954            return;}
2955            goto T1011;
2956    T1011:;
2957            base[2]= Cnil;
2958            vs_top=(vs_base=base+2)+1;
2959            return;
2960            goto T1008;
2961    T1008:;
2962            if(!(type_of((V271))==t_cons)){
2963            goto T1018;}
2964            if(!(type_of((V272))==t_cons)){
2965            goto T1021;}
2966            base[2]= car((V271));
2967            base[3]= car((V272));
2968            vs_top=(vs_base=base+2)+2;
2969            (void) (*Lnk358)();
2970            vs_top=sup;
2971            V271= cdr((V271));
2972            V272= cdr((V272));
2973            goto TTL;
2974            goto T1021;
2975    T1021:;
2976            base[2]= car((V271));
2977            base[3]= (V272);
2978            vs_top=(vs_base=base+2)+2;
2979            (void) (*Lnk358)();
2980            vs_top=sup;
2981            V271= cdr((V271));
2982            goto TTL;
2983            goto T1018;
2984    T1018:;
2985            base[2]= VV[148];
2986            base[3]= (V271);
2987            vs_top=(vs_base=base+2)+2;
2988            Lerror();
2989            return;
2990            }
2991    }
2992    /*      function definition for LOOP-MAYBE-BIND-FORM    */
2993    
2994    static void L64()
2995    {register object *base=vs_base;
2996            register object *sup=base+VM54; VC54
2997            vs_reserve(VM54);
2998            {object V276;
2999            object V277;
3000            check_arg(2);
3001            V276=(base[0]);
3002            V277=(base[1]);
3003            vs_top=sup;
3004            goto TTL;
3005    TTL:;
3006            base[2]= (V276);
3007            vs_top=(vs_base=base+2)+1;
3008            (void) (*Lnk360)();
3009            vs_top=sup;
3010            if((vs_base[0])==Cnil){
3011            goto T1038;}
3012            base[2]= (V276);
3013            vs_top=(vs_base=base+2)+1;
3014            return;
3015            goto T1038;
3016    T1038:;
3017            base[3]= VV[149];
3018            vs_top=(vs_base=base+3)+1;
3019            (void) (*Lnk327)();
3020            vs_top=sup;
3021            base[2]= vs_base[0];
3022            base[3]= (V276);
3023            base[4]= (V277);
3024            vs_top=(vs_base=base+2)+3;
3025            (void) (*Lnk359)();
3026            return;
3027            }
3028    }
3029    /*      function definition for LOOP-DO-IF      */
3030    
3031    static void L65()
3032    {register object *base=vs_base;
3033            register object *sup=base+VM55; VC55
3034            vs_reserve(VM55);
3035            bds_check;
3036            {object V278;
3037            object V279;
3038            check_arg(2);
3039            V278=(base[0]);
3040            V279=(base[1]);
3041            vs_top=sup;
3042            goto TTL;
3043    TTL:;
3044            {object V280;
3045            vs_base=vs_top;
3046            (void) (*Lnk361)();
3047            vs_top=sup;
3048            V280= vs_base[0];
3049            bds_bind(VV[115],Ct);
3050            base[3]= Cnil;
3051            {object V281;
3052            object V282;
3053            base[4]= (V278);
3054            vs_top=(vs_base=base+4)+1;
3055            L66(base);
3056            vs_top=sup;
3057            V281= vs_base[0];
3058            base[4]= car(symbol_value(VV[89]));
3059            base[5]= VV[150];
3060            vs_top=(vs_base=base+4)+2;
3061            (void) (*Lnk357)();
3062            vs_top=sup;
3063            if((vs_base[0])==Cnil){
3064            goto T1050;}
3065            vs_base=vs_top;
3066            (void) (*Lnk350)();
3067            vs_top=sup;
3068            base[4]= VV[150];
3069            vs_top=(vs_base=base+4)+1;
3070            L66(base);
3071            vs_top=sup;
3072            V283= vs_base[0];
3073            V282= make_cons(V283,Cnil);
3074            goto T1048;
3075            goto T1050;
3076    T1050:;
3077            V282= Cnil;
3078            goto T1048;
3079    T1048:;
3080            base[4]= car(symbol_value(VV[89]));
3081            base[5]= VV[151];
3082            vs_top=(vs_base=base+4)+2;
3083            (void) (*Lnk357)();
3084            vs_top=sup;
3085            if((vs_base[0])==Cnil){
3086            goto T1057;}
3087            vs_base=vs_top;
3088            (void) (*Lnk350)();
3089            vs_top=sup;
3090            goto T1057;
3091    T1057:;
3092            if((base[3])==Cnil){
3093            goto T1062;}
3094            V280= list(3,VV[11],base[3],(V280));
3095            goto T1062;
3096    T1062:;
3097            if(((V279))==Cnil){
3098            goto T1069;}
3099            V284= list(2,VV[36],(V280));
3100            goto T1067;
3101            goto T1069;
3102    T1069:;
3103            V284= (V280);
3104            goto T1067;
3105    T1067:;
3106            base[4]= listA(4,VV[71],V284,(V281),(V282));
3107            vs_top=(vs_base=base+4)+1;
3108            (void) (*Lnk354)();
3109            bds_unwind1;
3110            return;}}
3111            }
3112    }
3113    /*      function definition for LOOP-DO-INITIALLY       */
3114    
3115    static void L67()
3116    {register object *base=vs_base;
3117            register object *sup=base+VM56; VC56
3118            vs_reserve(VM56);
3119            check_arg(0);
3120            vs_top=sup;
3121            goto TTL;
3122    TTL:;
3123            base[0]= VV[156];
3124            vs_top=(vs_base=base+0)+1;
3125            (void) (*Lnk362)();
3126            vs_top=sup;
3127            {object V285;
3128            vs_base=vs_top;
3129            (void) (*Lnk363)();
3130            vs_top=sup;
3131            V285= vs_base[0];
3132            setq(VV[106],make_cons((V285),symbol_value(VV[106])));
3133            base[1]= symbol_value(VV[106]);
3134            vs_top=(vs_base=base+1)+1;
3135            return;}
3136    }
3137    /*      function definition for LOOP-DO-FINALLY */
3138    
3139    static void L68()
3140    {register object *base=vs_base;
3141            register object *sup=base+VM57; VC57
3142            vs_reserve(VM57);
3143            check_arg(0);
3144            vs_top=sup;
3145            goto TTL;
3146    TTL:;
3147            base[0]= VV[157];
3148            vs_top=(vs_base=base+0)+1;
3149            (void) (*Lnk362)();
3150            vs_top=sup;
3151            {object V286;
3152            vs_base=vs_top;
3153            (void) (*Lnk363)();
3154            vs_top=sup;
3155            V286= vs_base[0];
3156            setq(VV[112],make_cons((V286),symbol_value(VV[112])));
3157            base[1]= symbol_value(VV[112]);
3158            vs_top=(vs_base=base+1)+1;
3159            return;}
3160    }
3161    /*      function definition for LOOP-DO-DO      */
3162    
3163    static void L69()
3164    {register object *base=vs_base;
3165            register object *sup=base+VM58; VC58
3166            vs_reserve(VM58);
3167            check_arg(0);
3168            vs_top=sup;
3169            goto TTL;
3170    TTL:;
3171            vs_base=vs_top;
3172            (void) (*Lnk363)();
3173            vs_top=sup;
3174            base[0]= vs_base[0];
3175            vs_top=(vs_base=base+0)+1;
3176            (void) (*Lnk364)();
3177            return;
3178    }
3179    /*      function definition for LOOP-DO-NAMED   */
3180    
3181    static void L70()
3182    {register object *base=vs_base;
3183            register object *sup=base+VM59; VC59
3184            vs_reserve(VM59);
3185            check_arg(0);
3186            vs_top=sup;
3187            goto TTL;
3188    TTL:;
3189            {register object V287;
3190            vs_base=vs_top;
3191            (void) (*Lnk350)();
3192            vs_top=sup;
3193            V287= vs_base[0];
3194            if(type_of((V287))==t_symbol){
3195            goto T1081;}
3196            base[0]= VV[158];
3197            base[1]= (V287);
3198            vs_top=(vs_base=base+0)+2;
3199            (void) (*Lnk347)();
3200            vs_top=sup;
3201            goto T1081;
3202    T1081:;
3203            if((symbol_value(VV[108]))!=Cnil){
3204            goto T1087;}
3205            if((symbol_value(VV[109]))!=Cnil){
3206            goto T1087;}
3207            if((symbol_value(VV[113]))!=Cnil){
3208            goto T1087;}
3209            if((symbol_value(VV[115]))==Cnil){
3210            goto T1086;}
3211            goto T1087;
3212    T1087:;
3213            base[0]= VV[159];
3214            base[1]= (V287);
3215            vs_top=(vs_base=base+0)+2;
3216            (void) (*Lnk347)();
3217            vs_top=sup;
3218            goto T1086;
3219    T1086:;
3220            if((symbol_value(VV[118]))==Cnil){
3221            goto T1097;}
3222            base[0]= VV[160];
3223            base[1]= car(symbol_value(VV[118]));
3224            base[2]= (V287);
3225            vs_top=(vs_base=base+0)+3;
3226            (void) (*Lnk347)();
3227            vs_top=sup;
3228            goto T1097;
3229    T1097:;
3230            setq(VV[118],list(2,(V287),Cnil));
3231            base[0]= symbol_value(VV[118]);
3232            vs_top=(vs_base=base+0)+1;
3233            return;}
3234    }
3235    /*      function definition for LOOP-DO-RETURN  */
3236    
3237    static void L71()
3238    {register object *base=vs_base;
3239            register object *sup=base+VM60; VC60
3240            vs_reserve(VM60);
3241            check_arg(0);
3242            vs_top=sup;
3243            goto TTL;
3244    TTL:;
3245            vs_base=vs_top;
3246            (void) (*Lnk361)();
3247            vs_top=sup;
3248            base[1]= vs_base[0];
3249            vs_top=(vs_base=base+1)+1;
3250            (void) (*Lnk355)();
3251            vs_top=sup;
3252            base[0]= vs_base[0];
3253            vs_top=(vs_base=base+0)+1;
3254            (void) (*Lnk354)();
3255            return;
3256    }
3257    /*      function definition for MAKE-LOOP-COLLECTOR     */
3258    
3259    static void L72()
3260    {register object *base=vs_base;
3261            register object *sup=base+VM61; VC61
3262            vs_reserve(VM61);
3263            {object V288;
3264            object V289;
3265            object V290;
3266            object V291;
3267            object V292;
3268            object V293;
3269            parse_key(vs_base,FALSE,FALSE,6,VV[165],VV[166],VV[167],VV[365],VV[168],VV[366]);
3270            vs_top=sup;
3271            V288=(base[0]);
3272            V289=(base[1]);
3273            V290=(base[2]);
3274            V291=(base[3]);
3275            V292=(base[4]);
3276            V293=(base[5]);
3277            base[12]= VV[161];
3278            base[13]= (V288);
3279            base[14]= (V289);
3280            base[15]= (V290);
3281            base[16]= (V291);
3282            base[17]= (V292);
3283            base[18]= (V293);
3284            vs_top=(vs_base=base+12)+7;
3285            siLmake_structure();
3286            return;
3287            }
3288    }
3289    /*      function definition for LOOP-GET-COLLECTION-INFO        */
3290    
3291    static void L73()
3292    {register object *base=vs_base;
3293            register object *sup=base+VM62; VC62
3294            vs_reserve(VM62);
3295            {object V294;
3296            object V295;
3297            object V296;
3298            check_arg(3);
3299            V294=(base[0]);
3300            V295=(base[1]);
3301            V296=(base[2]);
3302            vs_top=sup;
3303            goto TTL;
3304    TTL:;
3305            base[3]= car(symbol_value(VV[89]));
3306            base[4]= VV[162];
3307            vs_top=(vs_base=base+3)+2;
3308            (void) (*Lnk357)();
3309            vs_top=sup;
3310            if((vs_base[0])!=Cnil){
3311            goto T1113;}
3312            setq(VV[119],Ct);
3313            goto T1113;
3314    T1113:;
3315            {object V297;
3316            register object V298;
3317            register object V299;
3318            vs_base=vs_top;
3319            (void) (*Lnk361)();
3320            vs_top=sup;
3321            V297= vs_base[0];
3322            V300= structure_ref(symbol_value(VV[97]),VV[39],6);
3323            if((/* INLINE-ARGS */V300)==Cnil){
3324            goto T1121;}
3325            V298= Cnil;
3326            goto T1120;
3327            goto T1121;
3328    T1121:;
3329            vs_base=vs_top;
3330            (void) (*Lnk367)();
3331            vs_top=sup;
3332            V298= vs_base[0];
3333            goto T1120;
3334    T1120:;
3335            base[3]= car(symbol_value(VV[89]));
3336            base[4]= VV[162];
3337            vs_top=(vs_base=base+3)+2;
3338            (void) (*Lnk357)();
3339            vs_top=sup;
3340            if((vs_base[0])==Cnil){
3341            goto T1125;}
3342            vs_base=vs_top;
3343            (void) (*Lnk350)();
3344            vs_top=sup;
3345            vs_base=vs_top;
3346            (void) (*Lnk350)();
3347            vs_top=sup;
3348            V299= vs_base[0];
3349            goto T1123;
3350            goto T1125;
3351    T1125:;
3352            V299= Cnil;
3353            goto T1123;
3354    T1123:;
3355            if(type_of((V299))==t_symbol){
3356            goto T1130;}
3357            base[3]= VV[163];
3358            base[4]= (V299);
3359            vs_top=(vs_base=base+3)+2;
3360            (void) (*Lnk347)();
3361            vs_top=sup;
3362            goto T1130;
3363    T1130:;
3364            if(((V298))!=Cnil){
3365            goto T1135;}{object V301;
3366            vs_base=vs_top;
3367            (void) (*Lnk367)();
3368            vs_top=sup;
3369            V301= vs_base[0];
3370            if(V301==Cnil)goto T1139;
3371            V298= V301;
3372            goto T1138;
3373            goto T1139;
3374    T1139:;}
3375            V298= (V296);
3376            goto T1138;
3377    T1138:;
3378            goto T1135;
3379    T1135:;
3380            {register object V302;{object V303;
3381            V303= symbol_value(VV[120]);
3382            V304= symbol_function(VV[369]);
3383            V302= (VFUN_NARGS=4,(*(LnkLI368))((V299),V303,VV[164],V304));}
3384            if(((V302))!=Cnil){
3385            goto T1145;}
3386            {object V305;
3387            base[4]= VV[165];
3388            base[5]= (V299);
3389            base[6]= VV[166];
3390            base[7]= (V295);
3391            base[8]= VV[167];
3392            base[9]= make_cons((V294),Cnil);
3393            base[10]= VV[168];
3394            base[11]= (V298);
3395            vs_top=(vs_base=base+4)+8;
3396            (void) (*Lnk370)();
3397            vs_top=sup;
3398            V302= vs_base[0];
3399            V305= (V302);
3400            setq(VV[120],make_cons((V305),symbol_value(VV[120])));
3401            goto T1143;}
3402            goto T1145;
3403    T1145:;
3404            V306= structure_ref((V302),VV[161],1);
3405            if((/* INLINE-ARGS */V306)==((V295))){
3406            goto T1158;}
3407            base[3]= VV[169];
3408            base[4]= (V299);
3409            V307= structure_ref((V302),VV[161],2);
3410            base[5]= car(/* INLINE-ARGS */V307);
3411            base[6]= (V294);
3412            vs_top=(vs_base=base+3)+4;
3413            (void) (*Lnk347)();
3414            vs_top=sup;
3415            goto T1158;
3416    T1158:;
3417            V308= structure_ref((V302),VV[161],4);
3418            if(equal((V298),/* INLINE-ARGS */V308)){
3419            goto T1165;}
3420            base[3]= VV[170];
3421            base[4]= (V299);
3422            base[5]= (V298);
3423            base[6]= structure_ref((V302),VV[161],4);
3424            vs_top=(vs_base=base+3)+4;
3425            (void) (*Lnk338)();
3426            vs_top=sup;
3427            V309= structure_ref((V302),VV[161],4);
3428            if(!((/* INLINE-ARGS */V309)==(Ct))){
3429            goto T1165;}
3430            (void)(structure_set((V302),VV[161],4,(V298)));
3431            goto T1165;
3432    T1165:;
3433            {object V312;
3434            V313= structure_ref(V302,VV[161],2);
3435            V312= make_cons(V294,/* INLINE-ARGS */V313);
3436            (void)(structure_set(V302,VV[161],2,(V312)));}
3437            goto T1143;
3438    T1143:;
3439            base[3]= (V302);
3440            base[4]= (V297);
3441            vs_top=(vs_base=base+3)+2;
3442            return;}}
3443            }
3444    }
3445    /*      function definition for LOOP-LIST-COLLECTION    */
3446    
3447    static void L74()
3448    {register object *base=vs_base;
3449            register object *sup=base+VM63; VC63
3450            vs_reserve(VM63);
3451            {object V314;
3452            check_arg(1);
3453            V314=(base[0]);
3454            vs_top=sup;
3455            goto TTL;
3456    TTL:;
3457            {register object V315;
3458            register object V316;
3459            base[1]= (V314);
3460            base[2]= VV[5];
3461            base[3]= VV[5];
3462            vs_top=(vs_base=base+1)+3;
3463            (void) (*Lnk371)();
3464            if(vs_base>=vs_top){vs_top=sup;goto T1182;}
3465            V315= vs_base[0];
3466            vs_base++;
3467            if(vs_base>=vs_top){vs_top=sup;goto T1183;}
3468            V316= vs_base[0];
3469            vs_top=sup;
3470            goto T1184;
3471            goto T1182;
3472    T1182:;
3473            V315= Cnil;
3474            goto T1183;
3475    T1183:;
3476            V316= Cnil;
3477            goto T1184;
3478    T1184:;
3479            {register object V317;
3480            V317= structure_ref((V315),VV[161],3);
3481            if(((V317))!=Cnil){
3482            goto T1186;}
3483            base[1]= VV[171];
3484            vs_top=(vs_base=base+1)+1;
3485            (void) (*Lnk327)();
3486            vs_top=sup;
3487            V318= vs_base[0];
3488            base[1]= VV[172];
3489            vs_top=(vs_base=base+1)+1;
3490            (void) (*Lnk327)();
3491            vs_top=sup;
3492            V319= vs_base[0];
3493            if((structure_ref((V315),VV[161],0))!=Cnil){
3494            goto T1196;}
3495            V320= Cnil;
3496            goto T1195;
3497            goto T1196;
3498    T1196:;
3499            V321= structure_ref((V315),VV[161],0);
3500            V320= make_cons(/* INLINE-ARGS */V321,Cnil);
3501            goto T1195;
3502    T1195:;
3503            V317= listA(3,V318,V319,V320);
3504            (void)(structure_set((V315),VV[161],3,(V317)));
3505            {object V322;
3506            V322= list(2,VV[173],(V317));
3507            setq(VV[107],make_cons((V322),symbol_value(VV[107])));}
3508            if((structure_ref((V315),VV[161],0))!=Cnil){
3509            goto T1186;}
3510            base[1]= listA(3,VV[174],car((V317)),cddr((V317)));
3511            vs_top=(vs_base=base+1)+1;
3512            (void) (*Lnk372)();
3513            vs_top=sup;
3514            goto T1186;
3515    T1186:;
3516            {object V323= (V314);
3517            if((V323!= VV[5]))goto T1205;
3518            V316= list(2,VV[5],(V316));
3519            goto T1204;
3520            goto T1205;
3521    T1205:;
3522            if((V323!= VV[373]))goto T1207;
3523            goto T1204;
3524            goto T1207;
3525    T1207:;
3526            if((V323!= VV[374]))goto T1208;
3527            if(!(type_of((V316))==t_cons)){
3528            goto T1209;}
3529            if((car((V316)))==(VV[5])){
3530            goto T1204;}
3531            goto T1209;
3532    T1209:;
3533            V316= list(2,VV[175],(V316));
3534            goto T1204;
3535            goto T1208;
3536    T1208:;
3537            FEerror("The ECASE key value ~s is illegal.",1,V323);
3538            goto T1204;}
3539            goto T1204;
3540    T1204:;
3541            base[1]= list(3,VV[176],(V317),(V316));
3542            vs_top=(vs_base=base+1)+1;
3543            (void) (*Lnk364)();
3544            return;}}
3545            }
3546    }
3547    /*      function definition for LOOP-SUM-COLLECTION     */
3548    
3549    static void L75()
3550    {register object *base=vs_base;
3551            register object *sup=base+VM64; VC64
3552            vs_reserve(VM64);
3553            {object V324;
3554            object V325;
3555            object V326;
3556            check_arg(3);
3557            V324=(base[0]);
3558            V325=(base[1]);
3559            V326=(base[2]);
3560            vs_top=sup;
3561            goto TTL;
3562    TTL:;
3563            {register object V327;
3564            object V328;
3565            base[3]= (V324);
3566            base[4]= VV[177];
3567            base[5]= (V326);
3568            vs_top=(vs_base=base+3)+3;
3569            (void) (*Lnk371)();
3570            if(vs_base>=vs_top){vs_top=sup;goto T1219;}
3571            V327= vs_base[0];
3572            vs_base++;
3573            if(vs_base>=vs_top){vs_top=sup;goto T1220;}
3574            V328= vs_base[0];
3575            vs_top=sup;
3576            goto T1221;
3577            goto T1219;
3578    T1219:;
3579            V327= Cnil;
3580            goto T1220;
3581    T1220:;
3582            V328= Cnil;
3583            goto T1221;
3584    T1221:;
3585            base[3]= structure_ref((V327),VV[161],4);
3586            base[4]= (V325);
3587            vs_top=(vs_base=base+3)+2;
3588            (void) (*Lnk375)();
3589            vs_top=sup;
3590            {register object V329;
3591            V329= structure_ref((V327),VV[161],3);
3592            if(((V329))!=Cnil){
3593            goto T1226;}{object V331;
3594            V331= structure_ref((V327),VV[161],0);
3595            if(V331==Cnil)goto T1233;
3596            base[3]= V331;
3597            goto T1232;
3598            goto T1233;
3599    T1233:;}
3600            base[4]= VV[178];
3601            vs_top=(vs_base=base+4)+1;
3602            (void) (*Lnk327)();
3603            vs_top=sup;
3604            base[3]= vs_base[0];
3605            goto T1232;
3606    T1232:;
3607            base[4]= Cnil;
3608            base[5]= structure_ref((V327),VV[161],4);
3609            vs_top=(vs_base=base+3)+3;
3610            (void) (*Lnk359)();
3611            vs_top=sup;
3612            V330= vs_base[0];
3613            V329= make_cons(V330,Cnil);
3614            (void)(structure_set((V327),VV[161],3,(V329)));
3615            if((structure_ref((V327),VV[161],0))!=Cnil){
3616            goto T1226;}
3617            V332= structure_ref((V327),VV[161],3);
3618            base[3]= car(/* INLINE-ARGS */V332);
3619            vs_top=(vs_base=base+3)+1;
3620            (void) (*Lnk372)();
3621            vs_top=sup;
3622            goto T1226;
3623    T1226:;
3624            if(!(((V324))==(VV[179]))){
3625            goto T1243;}
3626            V333= car((V329));
3627            base[4]= Ct;
3628            base[5]= car((V329));
3629            base[6]= list(2,VV[180],car((V329)));
3630            vs_top=(vs_base=base+4)+3;
3631            (void) (*Lnk331)();
3632            vs_top=sup;
3633            V334= vs_base[0];
3634            base[3]= list(3,VV[8],(V328),list(3,VV[11],/* INLINE-ARGS */V333,V334));
3635            goto T1241;
3636            goto T1243;
3637    T1243:;
3638            V335= car((V329));
3639            base[4]= Ct;
3640            base[5]= car((V329));
3641            base[6]= car((V329));
3642            vs_top=(vs_base=base+4)+3;
3643            (void) (*Lnk331)();
3644            vs_top=sup;
3645            V336= vs_base[0];
3646            base[3]= list(3,VV[11],/* INLINE-ARGS */V335,list(3,VV[181],V336,(V328)));
3647            goto T1241;
3648    T1241:;
3649            vs_top=(vs_base=base+3)+1;
3650            (void) (*Lnk364)();
3651            return;}}
3652            }
3653    }
3654    /*      function definition for LOOP-MAXMIN-COLLECTION  */
3655    
3656    static void L76()
3657    {register object *base=vs_base;
3658            register object *sup=base+VM65; VC65
3659            vs_reserve(VM65);
3660            {object V337;
3661            check_arg(1);
3662            V337=(base[0]);
3663            vs_top=sup;
3664            goto TTL;
3665    TTL:;
3666            {register object V338;
3667            object V339;
3668            base[1]= (V337);
3669            base[2]= VV[182];
3670            base[3]= symbol_value(VV[183]);
3671            vs_top=(vs_base=base+1)+3;
3672            (void) (*Lnk371)();
3673            if(vs_base>=vs_top){vs_top=sup;goto T1257;}
3674            V338= vs_base[0];
3675            vs_base++;
3676            if(vs_base>=vs_top){vs_top=sup;goto T1258;}
3677            V339= vs_base[0];
3678            vs_top=sup;
3679            goto T1259;
3680            goto T1257;
3681    T1257:;
3682            V338= Cnil;
3683            goto T1258;
3684    T1258:;
3685            V339= Cnil;
3686            goto T1259;
3687    T1259:;
3688            base[1]= structure_ref((V338),VV[161],4);
3689            base[2]= symbol_value(VV[183]);
3690            vs_top=(vs_base=base+1)+2;
3691            (void) (*Lnk375)();
3692            vs_top=sup;
3693            {register object V340;
3694            V340= structure_ref((V338),VV[161],5);
3695            if(((V340))!=Cnil){
3696            goto T1264;}{object V341;
3697            V341= structure_ref((V338),VV[161],0);
3698            if(V341==Cnil)goto T1270;
3699            base[1]= V341;
3700            goto T1269;
3701            goto T1270;
3702    T1270:;}
3703            base[2]= VV[184];
3704            vs_top=(vs_base=base+2)+1;
3705            (void) (*Lnk327)();
3706            vs_top=sup;
3707            base[1]= vs_base[0];
3708            goto T1269;
3709    T1269:;
3710            base[2]= structure_ref((V338),VV[161],4);
3711            vs_top=(vs_base=base+1)+2;
3712            (void) (*Lnk376)();
3713            vs_top=sup;
3714            V340= vs_base[0];
3715            (void)(structure_set((V338),VV[161],5,(V340)));
3716            if((structure_ref((V338),VV[161],0))!=Cnil){
3717            goto T1264;}
3718            base[1]= structure_ref((V340),VV[18],0);
3719            vs_top=(vs_base=base+1)+1;
3720            (void) (*Lnk372)();
3721            vs_top=sup;
3722            goto T1264;
3723    T1264:;
3724            base[1]= (V337);
3725            base[2]= (V340);
3726            vs_top=(vs_base=base+1)+2;
3727            (void) (*Lnk377)();
3728            vs_top=sup;
3729            {object V342;
3730            V342= list(2,VV[185],(V340));
3731            setq(VV[107],make_cons((V342),symbol_value(VV[107])));}
3732            base[1]= list(4,VV[186],(V340),(V337),(V339));
3733            vs_top=(vs_base=base+1)+1;
3734            (void) (*Lnk364)();
3735            return;}}
3736            }
3737    }
3738    /*      function definition for LOOP-DO-ALWAYS  */
3739    
3740    static void L77()
3741    {register object *base=vs_base;
3742            register object *sup=base+VM66; VC66
3743            vs_reserve(VM66);
3744            {object V343;
3745            object V344;
3746            check_arg(2);
3747            V343=(base[0]);
3748            V344=(base[1]);
3749            vs_top=sup;
3750            goto TTL;
3751    TTL:;
3752            {object V345;
3753            vs_base=vs_top;
3754            (void) (*Lnk361)();
3755            vs_top=sup;
3756            V345= vs_base[0];
3757            if(((V343))==Cnil){
3758            goto T1285;}
3759            vs_base=vs_top;
3760            (void) (*Lnk362)();
3761            vs_top=sup;
3762            goto T1285;
3763    T1285:;
3764            if(((V344))==Cnil){
3765            goto T1292;}
3766            V346= VV[8];
3767            goto T1290;
3768            goto T1292;
3769    T1292:;
3770            V346= VV[187];
3771            goto T1290;
3772    T1290:;
3773            base[3]= Cnil;
3774            vs_top=(vs_base=base+3)+1;
3775            (void) (*Lnk355)();
3776            vs_top=sup;
3777            V347= vs_base[0];
3778            base[2]= list(3,V346,(V345),V347);
3779            vs_top=(vs_base=base+2)+1;
3780            (void) (*Lnk364)();
3781            vs_top=sup;
3782            base[2]= Ct;
3783            vs_top=(vs_base=base+2)+1;
3784            (void) (*Lnk372)();
3785            return;}
3786            }
3787    }
3788    /*      function definition for LOOP-DO-THEREIS */
3789    
3790    static void L78()
3791    {register object *base=vs_base;
3792            register object *sup=base+VM67; VC67
3793            vs_reserve(VM67);
3794            {object V348;
3795            check_arg(1);
3796            V348=(base[0]);
3797            vs_top=sup;
3798            goto TTL;
3799    TTL:;
3800            if(((V348))==Cnil){
3801            goto T1297;}
3802            vs_base=vs_top;
3803            (void) (*Lnk362)();
3804            vs_top=sup;
3805            goto T1297;
3806    T1297:;
3807            vs_base=vs_top;
3808            (void) (*Lnk378)();
3809            vs_top=sup;
3810            V349= vs_base[0];
3811            vs_base=vs_top;
3812            (void) (*Lnk361)();
3813            vs_top=sup;
3814            V350= vs_base[0];
3815            V351= list(3,VV[11],V349,V350);
3816            base[2]= symbol_value(VV[116]);
3817            vs_top=(vs_base=base+2)+1;
3818            (void) (*Lnk355)();
3819            vs_top=sup;
3820            V352= vs_base[0];
3821            base[1]= list(3,VV[8],/* INLINE-ARGS */V351,V352);
3822            vs_top=(vs_base=base+1)+1;
3823            (void) (*Lnk364)();
3824            vs_top=sup;
3825            base[1]= Cnil;
3826            vs_top=(vs_base=base+1)+1;
3827            (void) (*Lnk372)();
3828            return;
3829            }
3830    }
3831    /*      function definition for LOOP-DO-WHILE   */
3832    
3833    static void L79()
3834    {register object *base=vs_base;
3835            register object *sup=base+VM68; VC68
3836            vs_reserve(VM68);
3837            {object V353;
3838            object V354;
3839            check_arg(2);
3840            V353=(base[0]);
3841            V354=(base[1]);
3842            vs_top=sup;
3843            goto TTL;
3844    TTL:;
3845            {object V355;
3846            vs_base=vs_top;
3847            (void) (*Lnk361)();
3848            vs_top=sup;
3849            V355= vs_base[0];
3850            base[3]= (V354);
3851            vs_top=(vs_base=base+3)+1;
3852            (void) (*Lnk362)();
3853            vs_top=sup;
3854            if(((V353))==Cnil){
3855            goto T1313;}
3856            V356= VV[8];
3857            goto T1311;
3858            goto T1313;
3859    T1313:;
3860            V356= VV[187];
3861            goto T1311;
3862    T1311:;
3863            base[3]= list(3,V356,(V355),VV[188]);
3864            vs_top=(vs_base=base+3)+1;
3865            (void) (*Lnk354)();
3866            return;}
3867            }
3868    }
3869    /*      function definition for LOOP-DO-WITH    */
3870    
3871    static void L80()
3872    {register object *base=vs_base;
3873            register object *sup=base+VM69; VC69
3874            vs_reserve(VM69);
3875            check_arg(0);
3876            vs_top=sup;
3877            goto TTL;
3878    TTL:;
3879            base[0]= VV[189];
3880            vs_top=(vs_base=base+0)+1;
3881            (void) (*Lnk362)();
3882            vs_top=sup;
3883            {register object V357;
3884            register object V358;
3885            register object V359;
3886            V357= Cnil;
3887            V358= Cnil;
3888            V359= Cnil;
3889            goto T1318;
3890    T1318:;
3891            vs_base=vs_top;
3892            (void) (*Lnk350)();
3893            vs_top=sup;
3894            V357= vs_base[0];
3895            base[0]= (V357);
3896            vs_top=(vs_base=base+0)+1;
3897            (void) (*Lnk367)();
3898            vs_top=sup;
3899            V359= vs_base[0];
3900            base[0]= car(symbol_value(VV[89]));
3901            base[1]= VV[190];
3902            vs_top=(vs_base=base+0)+2;
3903            (void) (*Lnk357)();
3904            vs_top=sup;
3905            if((vs_base[0])==Cnil){
3906            goto T1329;}
3907            vs_base=vs_top;
3908            (void) (*Lnk350)();
3909            vs_top=sup;
3910            vs_base=vs_top;
3911            (void) (*Lnk361)();
3912            vs_top=sup;
3913            V358= vs_base[0];
3914            goto T1327;
3915            goto T1329;
3916    T1329:;
3917            V358= Cnil;
3918            goto T1327;
3919    T1327:;
3920            base[0]= (V357);
3921            base[1]= (V358);
3922            base[2]= (V359);
3923            vs_top=(vs_base=base+0)+3;
3924            (void) (*Lnk359)();
3925            vs_top=sup;
3926            base[0]= car(symbol_value(VV[89]));
3927            base[1]= VV[155];
3928            vs_top=(vs_base=base+0)+2;
3929            (void) (*Lnk357)();
3930            vs_top=sup;
3931            if((vs_base[0])==Cnil){
3932            goto T1340;}
3933            vs_base=vs_top;
3934            (void) (*Lnk350)();
3935            vs_top=sup;
3936            goto T1338;
3937            goto T1340;
3938    T1340:;
3939            vs_base=vs_top;
3940            (void) (*Lnk349)();
3941            return;
3942            goto T1338;
3943    T1338:;
3944            goto T1318;}
3945    }
3946    /*      function definition for LOOP-HACK-ITERATION     */
3947    
3948    static void L81()
3949    {register object *base=vs_base;
3950            register object *sup=base+VM70; VC70
3951            vs_reserve(VM70);
3952            {register object V360;
3953            check_arg(1);
3954            V360=(base[0]);
3955            vs_top=sup;
3956            goto TTL;
3957    TTL:;
3958            {register object V361;
3959            register object V362;
3960            register object V363;
3961            register object V364;
3962            register object V365;
3963            register object V366;
3964            register object V367;
3965            register object V368;
3966            register object V369;
3967            object V370;
3968            V361= Cnil;
3969            V362= Cnil;
3970            V363= Cnil;
3971            V364= Cnil;
3972            V365= Cnil;
3973            V366= Cnil;
3974            V367= Cnil;
3975            V368= Cnil;
3976            V369= Cnil;
3977            V370= Cnil;
3978            goto T1347;
3979    T1347:;
3980            base[2]= car((V360));
3981            vs_top=(vs_base=base+2)+1;
3982            Lsymbol_function();
3983            vs_top=sup;
3984            base[1]= vs_base[0];
3985            {object V371;
3986            V371= cdr((V360));
3987             vs_top=base+2;
3988             while(!endp(V371))
3989             {vs_push(car(V371));V371=cdr(V371);}
3990            vs_base=base+2;}
3991            super_funcall_no_event(base[1]);
3992            vs_top=sup;
3993            V370= vs_base[0];
3994            V369= (V370);
3995            if((car((V369)))!=Cnil){
3996            goto T1357;}
3997            goto T1356;
3998            goto T1357;
3999    T1357:;
4000            {object V372;
4001            V372= car((V369));
4002            V361= make_cons((V372),(V361));}
4003            goto T1356;
4004    T1356:;
4005            V369= cdr((V369));
4006            base[1]= car((V369));
4007            vs_top=(vs_base=base+1)+1;
4008            Lcopy_list();
4009            vs_top=sup;
4010            V373= vs_base[0];
4011            V362= nconc((V362),V373);
4012            V369= cdr((V369));
4013            if((car((V369)))!=Cnil){
4014            goto T1367;}
4015            goto T1366;
4016            goto T1367;
4017    T1367:;
4018            {object V374;
4019            V374= car((V369));
4020            V363= make_cons((V374),(V363));}
4021            goto T1366;
4022    T1366:;
4023            V369= cdr((V369));
4024            base[1]= car((V369));
4025            vs_top=(vs_base=base+1)+1;
4026            Lcopy_list();
4027            vs_top=sup;
4028            V375= vs_base[0];
4029            V364= nconc((V364),V375);
4030            V369= cdr((V369));
4031            if((symbol_value(VV[110]))==Cnil){
4032            goto T1379;}
4033            base[1]= VV[191];
4034            vs_top=(vs_base=base+1)+1;
4035            (void) (*Lnk347)();
4036            vs_top=sup;
4037            goto T1379;
4038    T1379:;
4039            if(((V369))!=Cnil){
4040            goto T1383;}
4041            V369= (V370);
4042            goto T1383;
4043    T1383:;
4044            if((car((V369)))==Cnil){
4045            goto T1387;}
4046            {object V376;
4047            V376= car((V369));
4048            V365= make_cons((V376),(V365));}
4049            goto T1387;
4050    T1387:;
4051            V369= cdr((V369));
4052            base[1]= car((V369));
4053            vs_top=(vs_base=base+1)+1;
4054            Lcopy_list();
4055            vs_top=sup;
4056            V377= vs_base[0];
4057            V366= nconc((V366),V377);
4058            V369= cdr((V369));
4059            if((car((V369)))==Cnil){
4060            goto T1397;}
4061            {object V378;
4062            V378= car((V369));
4063            V367= make_cons((V378),(V367));}
4064            goto T1397;
4065    T1397:;
4066            base[1]= cadr((V369));
4067            vs_top=(vs_base=base+1)+1;
4068            Lcopy_list();
4069            vs_top=sup;
4070            V379= vs_base[0];
4071            V368= nconc((V368),V379);
4072            base[1]= car(symbol_value(VV[89]));
4073            base[2]= VV[155];
4074            vs_top=(vs_base=base+1)+2;
4075            (void) (*Lnk357)();
4076            vs_top=sup;
4077            if((vs_base[0])!=Cnil){
4078            goto T1407;}
4079            base[1]= (V368);
4080            vs_top=(vs_base=base+1)+1;
4081            (void) (*Lnk337)();
4082            vs_top=sup;
4083            V380= vs_base[0];
4084            base[1]= (V367);
4085            vs_top=(vs_base=base+1)+1;
4086            L82(base);
4087            vs_top=sup;
4088            V381= vs_base[0];
4089            base[1]= (V366);
4090            vs_top=(vs_base=base+1)+1;
4091            (void) (*Lnk336)();
4092            vs_top=sup;
4093            V382= vs_base[0];
4094            base[1]= (V365);
4095            vs_top=(vs_base=base+1)+1;
4096            L82(base);
4097            vs_top=sup;
4098            V383= vs_base[0];
4099            setq(VV[108],listA(5,V380,V381,V382,V383,symbol_value(VV[108])));
4100            base[1]= (V364);
4101            vs_top=(vs_base=base+1)+1;
4102            (void) (*Lnk337)();
4103            vs_top=sup;
4104            V384= vs_base[0];
4105            base[1]= (V363);
4106            vs_top=(vs_base=base+1)+1;
4107            L82(base);
4108            vs_top=sup;
4109            V385= vs_base[0];
4110            base[1]= (V362);
4111            vs_top=(vs_base=base+1)+1;
4112            (void) (*Lnk336)();
4113            vs_top=sup;
4114            V386= vs_base[0];
4115            base[1]= (V361);
4116            vs_top=(vs_base=base+1)+1;
4117            L82(base);
4118            vs_top=sup;
4119            V387= vs_base[0];
4120            setq(VV[111],listA(5,V384,V385,V386,V387,symbol_value(VV[111])));
4121            vs_base=vs_top;
4122            (void) (*Lnk349)();
4123            vs_top=sup;
4124            base[1]= Cnil;
4125            vs_top=(vs_base=base+1)+1;
4126            return;
4127            goto T1407;
4128    T1407:;
4129            vs_base=vs_top;
4130            (void) (*Lnk350)();
4131            vs_top=sup;
4132            if((structure_ref(symbol_value(VV[97]),VV[39],7))!=Cnil){
4133            goto T1434;}
4134            base[1]= car(symbol_value(VV[89]));
4135            base[2]= structure_ref(symbol_value(VV[97]),VV[39],1);
4136            vs_top=(vs_base=base+1)+2;
4137            (void) (*Lnk351)();
4138            vs_top=sup;
4139            V369= vs_base[0];
4140            if(((V369))==Cnil){
4141            goto T1434;}
4142            vs_base=vs_top;
4143            (void) (*Lnk350)();
4144            vs_top=sup;
4145            V360= (V369);
4146            goto T1434;
4147    T1434:;
4148            goto T1347;}
4149            }
4150    }
4151    /*      function definition for LOOP-DO-FOR     */
4152    
4153    static void L83()
4154    {register object *base=vs_base;
4155            register object *sup=base+VM71; VC71
4156            vs_reserve(VM71);
4157            check_arg(0);
4158            vs_top=sup;
4159            goto TTL;
4160    TTL:;
4161            {object V388;
4162            object V389;
4163            object V390;
4164            object V391;
4165            object V392;
4166            vs_base=vs_top;
4167            (void) (*Lnk350)();
4168            vs_top=sup;
4169            V388= vs_base[0];
4170            base[3]= (V388);
4171            vs_top=(vs_base=base+3)+1;
4172            (void) (*Lnk367)();
4173            vs_top=sup;
4174            V389= vs_base[0];
4175            vs_base=vs_top;
4176            (void) (*Lnk350)();
4177            vs_top=sup;
4178            V390= vs_base[0];
4179            V391= Cnil;
4180            V392= Cnil;
4181            vs_base=vs_top;
4182            (void) (*Lnk361)();
4183            vs_top=sup;
4184            V391= vs_base[0];
4185            if(!(type_of((V390))==t_symbol)){
4186            goto T1455;}
4187            base[3]= (V390);
4188            base[4]= structure_ref(symbol_value(VV[97]),VV[39],2);
4189            vs_top=(vs_base=base+3)+2;
4190            (void) (*Lnk351)();
4191            vs_top=sup;
4192            V392= vs_base[0];
4193            if(((V392))!=Cnil){
4194            goto T1454;}
4195            goto T1455;
4196    T1455:;
4197            base[3]= VV[194];
4198            base[4]= (V390);
4199            vs_top=(vs_base=base+3)+2;
4200            (void) (*Lnk347)();
4201            vs_top=sup;
4202            goto T1454;
4203    T1454:;
4204            base[3]= car((V392));
4205            base[4]= (V388);
4206            base[5]= (V391);
4207            base[6]= (V389);
4208            {object V393;
4209            V393= cdr((V392));
4210             vs_top=base+7;
4211             while(!endp(V393))
4212             {vs_push(car(V393));V393=cdr(V393);}
4213            vs_base=base+4;}
4214            super_funcall_no_event(base[3]);
4215            return;}
4216    }
4217    /*      function definition for LOOP-DO-REPEAT  */
4218    
4219    static void L84()
4220    {register object *base=vs_base;
4221            register object *sup=base+VM72; VC72
4222            vs_reserve(VM72);
4223            check_arg(0);
4224            vs_top=sup;
4225            goto TTL;
4226    TTL:;
4227            {register object V394;
4228            register object V395;
4229            vs_base=vs_top;
4230            (void) (*Lnk361)();
4231            vs_top=sup;
4232            V394= vs_base[0];
4233            vs_base=vs_top;
4234            (void) (*Lnk367)();
4235            vs_top=sup;
4236            base[0]= vs_base[0];
4237            base[1]= symbol_value(VV[183]);
4238            vs_top=(vs_base=base+0)+2;
4239            (void) (*Lnk375)();
4240            vs_top=sup;
4241            V395= vs_base[0];
4242            if(!(type_of((V394))==t_cons)){
4243            goto T1473;}
4244            if(!((car((V394)))==(VV[195]))){
4245            goto T1473;}
4246            base[0]= cadr((V394));
4247            base[1]= (V395);
4248            vs_top=(vs_base=base+0)+2;
4249            (void) (*Lnk326)();
4250            vs_top=sup;
4251            if((vs_base[0])==Cnil){
4252            goto T1473;}
4253            V395= cadr((V394));
4254            goto T1473;
4255    T1473:;
4256            {object V396;
4257            object V397;
4258            object V398;
4259            base[0]= (V394);
4260            base[1]= (V395);
4261            vs_top=(vs_base=base+0)+2;
4262            (void) (*Lnk379)();
4263            if(vs_base>=vs_top){vs_top=sup;goto T1486;}
4264            V396= vs_base[0];
4265            vs_base++;
4266            if(vs_base>=vs_top){vs_top=sup;goto T1487;}
4267            V397= vs_base[0];
4268            vs_base++;
4269            if(vs_base>=vs_top){vs_top=sup;goto T1488;}
4270            V398= vs_base[0];
4271            vs_top=sup;
4272            goto T1489;
4273            goto T1486;
4274    T1486:;
4275            V396= Cnil;
4276            goto T1487;
4277    T1487:;
4278            V397= Cnil;
4279            goto T1488;
4280    T1488:;
4281            V398= Cnil;
4282            goto T1489;
4283    T1489:;
4284            if(((V397))==Cnil){
4285            goto T1491;}
4286            if(!(number_compare((V398),small_fixnum(1))<=0)){
4287            goto T1491;}
4288            base[0]= listA(6,Ct,Cnil,Cnil,Cnil,(number_compare((V398),small_fixnum(0))<=0?Ct:Cnil),VV[196]);
4289            vs_top=(vs_base=base+0)+1;
4290            return;
4291            goto T1491;
4292    T1491:;
4293            {register object V399;
4294            base[1]= VV[197];
4295            vs_top=(vs_base=base+1)+1;
4296            (void) (*Lnk327)();
4297            vs_top=sup;
4298            base[0]= vs_base[0];
4299            base[1]= (V396);
4300            base[2]= (V395);
4301            vs_top=(vs_base=base+0)+3;
4302            (void) (*Lnk359)();
4303            vs_top=sup;
4304            V399= vs_base[0];
4305            if(((V397))==Cnil){
4306            goto T1501;}
4307            V400= list(2,VV[36],list(2,VV[198],list(3,VV[11],(V399),list(2,VV[199],(V399)))));
4308            base[0]= make_cons(/* INLINE-ARGS */V400,VV[200]);
4309            vs_top=(vs_base=base+0)+1;
4310            return;
4311            goto T1501;
4312    T1501:;
4313            V401= list(2,VV[201],list(3,VV[11],(V399),list(2,VV[199],(V399))));
4314            base[0]= make_cons(/* INLINE-ARGS */V401,VV[202]);
4315            vs_top=(vs_base=base+0)+1;
4316            return;}}}
4317    }
4318    /*      function definition for LOOP-WHEN-IT-VARIABLE   */
4319    
4320    static void L85()
4321    {register object *base=vs_base;
4322            register object *sup=base+VM73; VC73
4323            vs_reserve(VM73);
4324            check_arg(0);
4325            vs_top=sup;
4326            goto TTL;
4327    TTL:;
4328            if(symbol_value(VV[116])!=Cnil){
4329            base[0]= symbol_value(VV[116]);
4330            vs_top=(vs_base=base+0)+1;
4331            return;}
4332            base[1]= VV[203];
4333            vs_top=(vs_base=base+1)+1;
4334            (void) (*Lnk327)();
4335            vs_top=sup;
4336            base[0]= vs_base[0];
4337            base[1]= Cnil;
4338            base[2]= Cnil;
4339            vs_top=(vs_base=base+0)+3;
4340            (void) (*Lnk359)();
4341            vs_top=sup;
4342            setq(VV[116],vs_base[0]);
4343            base[0]= symbol_value(VV[116]);
4344            vs_top=(vs_base=base+0)+1;
4345            return;
4346    }
4347    /*      function definition for LOOP-ANSI-FOR-EQUALS    */
4348    
4349    static void L86()
4350    {register object *base=vs_base;
4351            register object *sup=base+VM74; VC74
4352            vs_reserve(VM74);
4353            {register object V402;
4354            object V403;
4355            object V404;
4356            check_arg(3);
4357            V402=(base[0]);
4358            V403=(base[1]);
4359            V404=(base[2]);
4360            vs_top=sup;
4361            goto TTL;
4362    TTL:;
4363            base[3]= (V402);
4364            base[4]= Cnil;
4365            base[5]= (V404);
4366            vs_top=(vs_base=base+3)+3;
4367            (void) (*Lnk380)();
4368            vs_top=sup;
4369            base[3]= car(symbol_value(VV[89]));
4370            base[4]= VV[204];
4371            vs_top=(vs_base=base+3)+2;
4372            (void) (*Lnk357)();
4373            vs_top=sup;
4374            if((vs_base[0])==Cnil){
4375            goto T1513;}
4376            vs_base=vs_top;
4377            (void) (*Lnk350)();
4378            vs_top=sup;
4379            vs_base=vs_top;
4380            (void) (*Lnk361)();
4381            vs_top=sup;
4382            V405= vs_base[0];
4383            V406= list(2,(V402),V405);
4384            base[3]= listA(7,Cnil,/* INLINE-ARGS */V406,Cnil,Cnil,Cnil,list(2,(V402),(V403)),VV[205]);
4385            vs_top=(vs_base=base+3)+1;
4386            return;
4387            goto T1513;
4388    T1513:;
4389            base[3]= listA(3,Cnil,list(2,(V402),(V403)),VV[206]);
4390            vs_top=(vs_base=base+3)+1;
4391            return;
4392            }
4393    }
4394    /*      function definition for LOOP-FOR-ACROSS */
4395    
4396    static void L87()
4397    {register object *base=vs_base;
4398            register object *sup=base+VM75; VC75
4399            vs_reserve(VM75);
4400            {object V407;
4401            object V408;
4402            object V409;
4403            check_arg(3);
4404            V407=(base[0]);
4405            V408=(base[1]);
4406            V409=(base[2]);
4407            vs_top=sup;
4408            goto TTL;
4409    TTL:;
4410            base[3]= (V407);
4411            base[4]= Cnil;
4412            base[5]= (V409);
4413            vs_top=(vs_base=base+3)+3;
4414            (void) (*Lnk380)();
4415            vs_top=sup;
4416            {object V410;
4417            register object V411;
4418            base[3]= VV[207];
4419            vs_top=(vs_base=base+3)+1;
4420            (void) (*Lnk327)();
4421            vs_top=sup;
4422            V410= vs_base[0];
4423            base[3]= VV[208];
4424            vs_top=(vs_base=base+3)+1;
4425            (void) (*Lnk327)();
4426            vs_top=sup;
4427            V411= vs_base[0];
4428            {register object V412;
4429            object V413;
4430            object V414;
4431            base[3]= (V408);
4432            base[4]= VV[209];
4433            vs_top=(vs_base=base+3)+2;
4434            (void) (*Lnk379)();
4435            if(vs_base>=vs_top){vs_top=sup;goto T1530;}
4436            V412= vs_base[0];
4437            vs_base++;
4438            if(vs_base>=vs_top){vs_top=sup;goto T1531;}
4439            V413= vs_base[0];
4440            vs_base++;
4441            if(vs_base>=vs_top){vs_top=sup;goto T1532;}
4442            V414= vs_base[0];
4443            vs_top=sup;
4444            goto T1533;
4445            goto T1530;
4446    T1530:;
4447            V412= Cnil;
4448            goto T1531;
4449    T1531:;
4450            V413= Cnil;
4451            goto T1532;
4452    T1532:;
4453            V414= Cnil;
4454            goto T1533;
4455    T1533:;
4456            base[3]= (V410);
4457            base[4]= (V412);
4458            if(!(type_of((V412))==t_cons)){
4459            goto T1539;}
4460            if(!((car((V412)))==(VV[195]))){
4461            goto T1539;}
4462            base[5]= cadr((V412));
4463            goto T1537;
4464            goto T1539;
4465    T1539:;
4466            base[5]= VV[209];
4467            goto T1537;
4468    T1537:;
4469            vs_top=(vs_base=base+3)+3;
4470            (void) (*Lnk359)();
4471            vs_top=sup;
4472            base[3]= (V411);
4473            base[4]= small_fixnum(0);
4474            base[5]= VV[210];
4475            vs_top=(vs_base=base+3)+3;
4476            (void) (*Lnk359)();
4477            vs_top=sup;
4478            {long V415;
4479            object V416;
4480            register object V417;
4481            object V418;
4482            object V419;
4483            object V420;
4484            V415= 0;
4485            if(((V413))!=Cnil){
4486            goto T1550;}
4487            {object V421;
4488            base[7]= VV[211];
4489            vs_top=(vs_base=base+7)+1;
4490            (void) (*Lnk327)();
4491            vs_top=sup;
4492            V421= vs_base[0];
4493            {object V422;
4494            V422= list(3,VV[11],(V421),list(2,VV[212],(V410)));
4495            setq(VV[106],make_cons((V422),symbol_value(VV[106])));}
4496            base[7]= (V421);
4497            base[8]= small_fixnum(0);
4498            base[9]= VV[210];
4499            vs_top=(vs_base=base+7)+3;
4500            (void) (*Lnk359)();
4501            vs_top=sup;
4502            V416= vs_base[0];
4503            goto T1548;}
4504            goto T1550;
4505    T1550:;
4506            V415= (long)length((V414));
4507            V416= make_fixnum(V415);
4508            goto T1548;
4509    T1548:;
4510            V417= list(3,VV[213],(V411),(V416));
4511            V418= (V417);
4512            V419= list(2,(V407),list(3,VV[214],(V410),(V411)));
4513            V420= list(2,(V411),list(2,VV[180],(V411)));
4514            if(((V413))==Cnil){
4515            goto T1565;}
4516            V417= ((V415)==(0)?Ct:Cnil);
4517            if(!((V415)<=(1))){
4518            goto T1565;}
4519            V418= Ct;
4520            goto T1565;
4521    T1565:;
4522            if(((((V417))==((V418))?Ct:Cnil))==Cnil){
4523            goto T1574;}
4524            V423= Cnil;
4525            goto T1573;
4526            goto T1574;
4527    T1574:;
4528            V423= list(4,(V417),(V419),Cnil,(V420));
4529            goto T1573;
4530    T1573:;
4531            base[7]= listA(5,(V418),(V419),Cnil,(V420),V423);
4532            vs_top=(vs_base=base+7)+1;
4533            return;}}}
4534            }
4535    }
4536    /*      function definition for LOOP-LIST-STEP  */
4537    
4538    static void L88()
4539    {register object *base=vs_base;
4540            register object *sup=base+VM76; VC76
4541            vs_reserve(VM76);
4542            {object V424;
4543            check_arg(1);
4544            V424=(base[0]);
4545            vs_top=sup;
4546            goto TTL;
4547    TTL:;
4548            {register object V425;
4549            base[1]= car(symbol_value(VV[89]));
4550            base[2]= VV[215];
4551            vs_top=(vs_base=base+1)+2;
4552            (void) (*Lnk357)();
4553            vs_top=sup;
4554            if((vs_base[0])==Cnil){
4555            goto T1578;}
4556            vs_base=vs_top;
4557            (void) (*Lnk350)();
4558            vs_top=sup;
4559            vs_base=vs_top;
4560            (void) (*Lnk361)();
4561            vs_top=sup;
4562            V425= vs_base[0];
4563            goto T1576;
4564            goto T1578;
4565    T1578:;
4566            V425= VV[216];
4567            goto T1576;
4568    T1576:;
4569            if(!(type_of((V425))==t_cons)){
4570            goto T1584;}
4571            if(!((car((V425)))==(VV[217]))){
4572            goto T1584;}
4573            base[1]= VV[218];
4574            vs_top=(vs_base=base+1)+1;
4575            (void) (*Lnk338)();
4576            vs_top=sup;
4577            base[1]= list(3,VV[219],(V425),(V424));
4578            base[2]= Cnil;
4579            vs_top=(vs_base=base+1)+2;
4580            return;
4581            goto T1584;
4582    T1584:;
4583            if(!(type_of((V425))==t_cons)){
4584            goto T1593;}
4585            if(!((car((V425)))==(VV[83]))){
4586            goto T1593;}
4587            base[1]= list(2,cadr((V425)),(V424));
4588            base[2]= cadr((V425));
4589            vs_top=(vs_base=base+1)+2;
4590            return;
4591            goto T1593;
4592    T1593:;
4593            base[3]= VV[220];
4594            vs_top=(vs_base=base+3)+1;
4595            (void) (*Lnk327)();
4596            vs_top=sup;
4597            base[2]= vs_base[0];
4598            base[3]= (V425);
4599            base[4]= VV[83];
4600            vs_top=(vs_base=base+2)+3;
4601            (void) (*Lnk359)();
4602            vs_top=sup;
4603            V426= vs_base[0];
4604            base[1]= list(3,VV[219],V426,(V424));
4605            base[2]= Cnil;
4606            vs_top=(vs_base=base+1)+2;
4607            return;}
4608            }
4609    }
4610    /*      function definition for LOOP-FOR-ON     */
4611    
4612    static void L89()
4613    {register object *base=vs_base;
4614            register object *sup=base+VM77; VC77
4615            vs_reserve(VM77);
4616            {register object V427;
4617            object V428;
4618            object V429;
4619            check_arg(3);
4620            V427=(base[0]);
4621            V428=(base[1]);
4622            V429=(base[2]);
4623            vs_top=sup;
4624            goto TTL;
4625    TTL:;
4626            {object V430;
4627            object V431;
4628            object V432;
4629            base[3]= (V428);
4630            vs_top=(vs_base=base+3)+1;
4631            (void) (*Lnk379)();
4632            if(vs_base>=vs_top){vs_top=sup;goto T1608;}
4633            V430= vs_base[0];
4634            vs_base++;
4635            if(vs_base>=vs_top){vs_top=sup;goto T1609;}
4636            V431= vs_base[0];
4637            vs_base++;
4638            if(vs_base>=vs_top){vs_top=sup;goto T1610;}
4639            V432= vs_base[0];
4640            vs_top=sup;
4641            goto T1611;
4642            goto T1608;
4643    T1608:;
4644            V430= Cnil;
4645            goto T1609;
4646    T1609:;
4647            V431= Cnil;
4648            goto T1610;
4649    T1610:;
4650            V432= Cnil;
4651            goto T1611;
4652    T1611:;
4653            {register object V433;
4654            V433= (V427);
4655            if(((V427))==Cnil){
4656            goto T1614;}
4657            if(!(type_of((V427))==t_symbol)){
4658            goto T1614;}
4659            base[3]= (V427);
4660            base[4]= (V430);
4661            base[5]= (V429);
4662            vs_top=(vs_base=base+3)+3;
4663            (void) (*Lnk380)();
4664            vs_top=sup;
4665            goto T1612;
4666            goto T1614;
4667    T1614:;
4668            vs_base=vs_top;
4669            (void) (*Lnk327)();
4670            vs_top=sup;
4671            V433= vs_base[0];
4672            base[3]= (V433);
4673            base[4]= (V430);
4674            base[5]= VV[5];
4675            vs_top=(vs_base=base+3)+3;
4676            (void) (*Lnk359)();
4677            vs_top=sup;
4678            base[3]= (V427);
4679            base[4]= Cnil;
4680            base[5]= (V429);
4681            vs_top=(vs_base=base+3)+3;
4682            (void) (*Lnk380)();
4683            vs_top=sup;
4684            goto T1612;
4685    T1612:;
4686            {object V434;
4687            object V435;
4688            base[3]= (V433);
4689            vs_top=(vs_base=base+3)+1;
4690            (void) (*Lnk381)();
4691            if(vs_base>=vs_top){vs_top=sup;goto T1631;}
4692            V434= vs_base[0];
4693            vs_base++;
4694            if(vs_base>=vs_top){vs_top=sup;goto T1632;}
4695            V435= vs_base[0];
4696            vs_top=sup;
4697            goto T1633;
4698            goto T1631;
4699    T1631:;
4700            V434= Cnil;
4701            goto T1632;
4702    T1632:;
4703            V435= Cnil;
4704            goto T1633;
4705    T1633:;
4706            {register object V436;
4707            object V437;
4708            base[4]= (((V427))==((V433))?Ct:Cnil);
4709            base[5]= (V433);
4710            base[6]= list(2,VV[221],(V433));
4711            vs_top=(vs_base=base+4)+3;
4712            (void) (*Lnk331)();
4713            vs_top=sup;
4714            V436= vs_base[0];
4715            V437= (V436);
4716            if(((V431))==Cnil){
4717            goto T1639;}
4718            if(!(type_of((V432))==t_cons||((V432))==Cnil)){
4719            goto T1639;}
4720            V436= (((V432))==Cnil?Ct:Cnil);
4721            goto T1639;
4722    T1639:;
4723            if(!(((V427))==((V433)))){
4724            goto T1646;}
4725            base[4]= Ct;
4726            base[5]= (V433);
4727            base[6]= (V434);
4728            vs_top=(vs_base=base+4)+3;
4729            (void) (*Lnk331)();
4730            vs_top=sup;
4731            V438= vs_base[0];
4732            base[4]= list(8,Cnil,list(2,(V433),V438),(V437),Cnil,Cnil,Cnil,(V436),Cnil);
4733            vs_top=(vs_base=base+4)+1;
4734            return;
4735            goto T1646;
4736    T1646:;
4737            {object V439;
4738            object V440;
4739            V439= list(2,(V427),(V433));
4740            V440= list(2,(V433),(V434));
4741            if(((((V436))==((V437))?Ct:Cnil))==Cnil){
4742            goto T1655;}
4743            V441= Cnil;
4744            goto T1654;
4745            goto T1655;
4746    T1655:;
4747            V441= list(4,(V436),(V439),Cnil,(V440));
4748            goto T1654;
4749    T1654:;
4750            base[4]= listA(5,(V437),(V439),Cnil,(V440),V441);
4751            vs_top=(vs_base=base+4)+1;
4752            return;}}}}}
4753            }
4754    }
4755    /*      function definition for LOOP-FOR-IN     */
4756    
4757    static void L90()
4758    {register object *base=vs_base;
4759            register object *sup=base+VM78; VC78
4760            vs_reserve(VM78);
4761            {object V442;
4762            object V443;
4763            object V444;
4764            check_arg(3);
4765            V442=(base[0]);
4766            V443=(base[1]);
4767            V444=(base[2]);
4768            vs_top=sup;
4769            goto TTL;
4770    TTL:;
4771            {object V445;
4772            object V446;
4773            object V447;
4774            base[3]= (V443);
4775            vs_top=(vs_base=base+3)+1;
4776            (void) (*Lnk379)();
4777            if(vs_base>=vs_top){vs_top=sup;goto T1659;}
4778            V445= vs_base[0];
4779            vs_base++;
4780            if(vs_base>=vs_top){vs_top=sup;goto T1660;}
4781            V446= vs_base[0];
4782            vs_base++;
4783            if(vs_base>=vs_top){vs_top=sup;goto T1661;}
4784            V447= vs_base[0];
4785            vs_top=sup;
4786            goto T1662;
4787            goto T1659;
4788    T1659:;
4789            V445= Cnil;
4790            goto T1660;
4791    T1660:;
4792            V446= Cnil;
4793            goto T1661;
4794    T1661:;
4795            V447= Cnil;
4796            goto T1662;
4797    T1662:;
4798            {register object V448;
4799            base[3]= VV[222];
4800            vs_top=(vs_base=base+3)+1;
4801            (void) (*Lnk327)();
4802            vs_top=sup;
4803            V448= vs_base[0];
4804            base[3]= (V442);
4805            base[4]= Cnil;
4806            base[5]= (V444);
4807            vs_top=(vs_base=base+3)+3;
4808            (void) (*Lnk380)();
4809            vs_top=sup;
4810            base[3]= (V448);
4811            base[4]= (V445);
4812            base[5]= VV[5];
4813            vs_top=(vs_base=base+3)+3;
4814            (void) (*Lnk359)();
4815            vs_top=sup;
4816            {object V449;
4817            object V450;
4818            base[3]= (V448);
4819            vs_top=(vs_base=base+3)+1;
4820            (void) (*Lnk381)();
4821            if(vs_base>=vs_top){vs_top=sup;goto T1675;}
4822            V449= vs_base[0];
4823            vs_base++;
4824            if(vs_base>=vs_top){vs_top=sup;goto T1676;}
4825            V450= vs_base[0];
4826            vs_top=sup;
4827            goto T1677;
4828            goto T1675;
4829    T1675:;
4830            V449= Cnil;
4831            goto T1676;
4832    T1676:;
4833            V450= Cnil;
4834            goto T1677;
4835    T1677:;
4836            {register object V451;
4837            object V452;
4838            object V453;
4839            object V454;
4840            V451= list(2,VV[223],(V448));
4841            V452= (V451);
4842            V453= list(2,(V442),list(2,VV[65],(V448)));
4843            V454= list(2,(V448),(V449));
4844            if(((V446))==Cnil){
4845            goto T1682;}
4846            if(!(type_of((V447))==t_cons||((V447))==Cnil)){
4847            goto T1682;}
4848            V451= (((V447))==Cnil?Ct:Cnil);
4849            goto T1682;
4850    T1682:;
4851            if(((((V451))==((V452))?Ct:Cnil))==Cnil){
4852            goto T1689;}
4853            V455= Cnil;
4854            goto T1688;
4855            goto T1689;
4856    T1689:;
4857            V455= list(4,(V451),(V453),Cnil,(V454));
4858            goto T1688;
4859    T1688:;
4860            base[6]= listA(5,(V452),(V453),Cnil,(V454),V455);
4861            vs_top=(vs_base=base+6)+1;
4862            return;}}}}
4863            }
4864    }
4865    /*      function definition for MAKE-LOOP-PATH  */
4866    
4867    static void L91()
4868    {register object *base=vs_base;
4869            register object *sup=base+VM79; VC79
4870            vs_reserve(VM79);
4871            {object V456;
4872            object V457;
4873            object V458;
4874            object V459;
4875            object V460;
4876            parse_key(vs_base,FALSE,FALSE,5,VV[226],VV[229],VV[230],VV[227],VV[228]);
4877            vs_top=sup;
4878            V456=(base[0]);
4879            V457=(base[1]);
4880            V458=(base[2]);
4881            V459=(base[3]);
4882            V460=(base[4]);
4883            base[10]= VV[224];
4884            base[11]= (V456);
4885            base[12]= (V457);
4886            base[13]= (V458);
4887            base[14]= (V459);
4888            base[15]= (V460);
4889            vs_top=(vs_base=base+10)+6;
4890            siLmake_structure();
4891            return;
4892            }
4893    }
4894    /*      function definition for ADD-LOOP-PATH   */
4895    
4896    static void L92()
4897    {register object *base=vs_base;
4898            register object *sup=base+VM80; VC80
4899            vs_reserve(VM80);
4900            bds_check;
4901            {object V461;
4902            object V462;
4903            register object V463;
4904            object V464;
4905            object V465;
4906            object V466;
4907            if(vs_top-vs_base<3) too_few_arguments();
4908            parse_key(vs_base+3,FALSE,FALSE,3,VV[229],VV[230],VV[228]);
4909            V461=(base[0]);
4910            V462=(base[1]);
4911            V463=(base[2]);
4912            vs_top=sup;
4913            V464=(base[3]);
4914            V465=(base[4]);
4915            V466=(base[5]);
4916            if(type_of((V461))==t_cons||((V461))==Cnil){
4917            goto T1697;}
4918            V461= make_cons((V461),Cnil);
4919            goto T1697;
4920    T1697:;
4921            bds_bind(VV[44],small_fixnum(4));
4922            bds_bind(VV[45],small_fixnum(4));
4923            goto T1703;
4924    T1703:;
4925            base[11]= (V463);
4926            base[12]= VV[39];
4927            vs_top=(vs_base=base+11)+2;
4928            (void) (*Lnk382)();
4929            vs_top=sup;
4930            if((vs_base[0])==Cnil){
4931            goto T1704;}
4932            bds_unwind1;
4933            bds_unwind1;
4934            goto T1701;
4935            goto T1704;
4936    T1704:;
4937            base[11]= VV[47];
4938            base[12]= VV[48];
4939            base[13]= VV[225];
4940            base[14]= (V463);
4941            base[15]= VV[39];
4942            vs_top=(vs_base=base+11)+5;
4943            Lcerror();
4944            vs_top=sup;
4945            base[11]= symbol_value(VV[50]);
4946            base[12]= VV[51];
4947            base[13]= VV[225];
4948            vs_top=(vs_base=base+11)+3;
4949            Lformat();
4950            vs_top=sup;
4951            base[11]= symbol_value(VV[50]);
4952            vs_top=(vs_base=base+11)+1;
4953            Lfinish_output();
4954            vs_top=sup;
4955            vs_base=vs_top;
4956            Lread();
4957            vs_top=sup;
4958            V463= vs_base[0];
4959            base[11]= symbol_value(VV[50]);
4960            base[12]= VV[52];
4961            vs_top=(vs_base=base+11)+2;
4962            Lformat();
4963            vs_top=sup;
4964            goto T1703;
4965            goto T1701;
4966    T1701:;
4967            {object V467;
4968            object V468;
4969            V467= structure_ref((V463),VV[39],3);
4970            base[9]= VV[226];
4971            {object V469;
4972            object V470= (V461);
4973            if(endp(V470)){
4974            base[10]= Cnil;
4975            goto T1732;}
4976            base[11]=V469=MMcons(Cnil,Cnil);
4977            goto T1733;
4978    T1733:;
4979            (V469->c.c_car)= symbol_name((V470->c.c_car));
4980            V470=MMcdr(V470);
4981            if(endp(V470)){
4982            base[10]= base[11];
4983            goto T1732;}
4984            V469=MMcdr(V469)=MMcons(Cnil,Cnil);
4985            goto T1733;}
4986            goto T1732;
4987    T1732:;
4988            base[11]= VV[227];
4989            base[12]= (V462);
4990            base[13]= VV[228];
4991            base[14]= (V466);
4992            base[15]= VV[229];
4993            {object V471;
4994            object V472= (V464);
4995            if(endp(V472)){
4996            base[16]= Cnil;
4997            goto T1740;}
4998            base[17]=V471=MMcons(Cnil,Cnil);
4999            goto T1741;
5000    T1741:;
5001            if(!(type_of((V472->c.c_car))==t_cons||((V472->c.c_car))==Cnil)){
5002            goto T1744;}
5003            (V471->c.c_car)= (V472->c.c_car);
5004            goto T1742;
5005            goto T1744;
5006    T1744:;
5007            (V471->c.c_car)= make_cons((V472->c.c_car),Cnil);
5008            goto T1742;
5009    T1742:;
5010            V472=MMcdr(V472);
5011            if(endp(V472)){
5012            base[16]= base[17];
5013            goto T1740;}
5014            V471=MMcdr(V471)=MMcons(Cnil,Cnil);
5015            goto T1741;}
5016            goto T1740;
5017    T1740:;
5018            base[17]= VV[230];
5019            base[18]= (V465);
5020            vs_top=(vs_base=base+9)+10;
5021            (void) (*Lnk383)();
5022            vs_top=sup;
5023            V468= vs_base[0];
5024            {register object V474;
5025            register object V475;
5026            V474= (V461);
5027            V475= car((V474));
5028            goto T1752;
5029    T1752:;
5030            if(!(endp_prop((V474)))){
5031            goto T1753;}
5032            goto T1748;
5033            goto T1753;
5034    T1753:;
5035            {register object V476;
5036            register object V477;
5037            register object V478;
5038            V476= symbol_name((V475));
5039            V477= (V467);
5040            V478= (V468);
5041            base[11]= (V476);
5042            base[12]= (V477);
5043            base[13]= (V478);
5044            vs_top=(vs_base=base+11)+3;
5045            siLhash_set();
5046            vs_top=sup;}
5047            V474= cdr((V474));
5048            V475= car((V474));
5049            goto T1752;}
5050            goto T1748;
5051    T1748:;
5052            base[9]= (V468);
5053            vs_top=(vs_base=base+9)+1;
5054            return;}
5055            }
5056    }
5057    /*      function definition for LOOP-FOR-BEING  */
5058    
5059    static void L93()
5060    {register object *base=vs_base;
5061            register object *sup=base+VM81; VC81
5062            vs_reserve(VM81);
5063            {object V479;
5064            object V480;
5065            object V481;
5066            check_arg(3);
5067            V479=(base[0]);
5068            V480=(base[1]);
5069            V481=(base[2]);
5070            vs_top=sup;
5071            goto TTL;
5072    TTL:;
5073            {register object V482;
5074            object V483;
5075            object V484;
5076            object V485;
5077            object V486;
5078            V482= Cnil;
5079            V483= Cnil;
5080            V484= Cnil;
5081            V485= Cnil;
5082            V486= Cnil;
5083            base[3]= (V480);
5084            base[4]= VV[231];
5085            vs_top=(vs_base=base+3)+2;
5086            (void) (*Lnk353)();
5087            vs_top=sup;
5088            if((vs_base[0])==Cnil){
5089            goto T1771;}
5090            vs_base=vs_top;
5091            (void) (*Lnk350)();
5092            vs_top=sup;
5093            V482= vs_base[0];
5094            goto T1769;
5095            goto T1771;
5096    T1771:;
5097            base[3]= car(symbol_value(VV[89]));
5098            base[4]= VV[155];
5099            vs_top=(vs_base=base+3)+2;
5100            (void) (*Lnk357)();
5101            vs_top=sup;
5102            if((vs_base[0])==Cnil){
5103            goto T1777;}
5104            vs_base=vs_top;
5105            (void) (*Lnk350)();
5106            vs_top=sup;
5107            V484= Ct;
5108            base[3]= car(symbol_value(VV[89]));
5109            base[4]= VV[232];
5110            vs_top=(vs_base=base+3)+2;
5111            (void) (*Lnk353)();
5112            vs_top=sup;
5113            if((vs_base[0])!=Cnil){
5114            goto T1784;}
5115            base[3]= VV[233];
5116            base[4]= car(symbol_value(VV[89]));
5117            vs_top=(vs_base=base+3)+2;
5118            (void) (*Lnk347)();
5119            vs_top=sup;
5120            goto T1784;
5121    T1784:;
5122            vs_base=vs_top;
5123            (void) (*Lnk350)();
5124            vs_top=sup;
5125            vs_base=vs_top;
5126            (void) (*Lnk350)();
5127            vs_top=sup;
5128            V482= vs_base[0];
5129            V487= list(2,VV[234],(V480));
5130            V486= make_cons(/* INLINE-ARGS */V487,Cnil);
5131            goto T1769;
5132            goto T1777;
5133    T1777:;
5134            base[3]= VV[235];
5135            vs_top=(vs_base=base+3)+1;
5136            (void) (*Lnk347)();
5137            vs_top=sup;
5138            goto T1769;
5139    T1769:;
5140            if(type_of((V482))==t_symbol){
5141            goto T1798;}
5142            base[3]= VV[236];
5143            base[4]= (V482);
5144            vs_top=(vs_base=base+3)+2;
5145            (void) (*Lnk347)();
5146            vs_top=sup;
5147            goto T1796;
5148            goto T1798;
5149    T1798:;
5150            base[3]= (V482);
5151            base[4]= structure_ref(symbol_value(VV[97]),VV[39],3);
5152            vs_top=(vs_base=base+3)+2;
5153            (void) (*Lnk351)();
5154            vs_top=sup;
5155            V483= vs_base[0];
5156            if(((V483))!=Cnil){
5157            goto T1803;}
5158            base[3]= VV[237];
5159            base[4]= (V482);
5160            vs_top=(vs_base=base+3)+2;
5161            (void) (*Lnk347)();
5162            vs_top=sup;
5163            goto T1796;
5164            goto T1803;
5165    T1803:;
5166            if(((V484))==Cnil){
5167            goto T1796;}
5168            if((structure_ref((V483),VV[224],2))!=Cnil){
5169            goto T1796;}
5170            base[3]= VV[238];
5171            base[4]= (V482);
5172            vs_top=(vs_base=base+3)+2;
5173            (void) (*Lnk347)();
5174            vs_top=sup;
5175            goto T1796;
5176    T1796:;
5177            {object V488;
5178            object V489;
5179            object V490;
5180            V488= structure_ref((V483),VV[224],3);
5181            base[3]= structure_ref((V483),VV[224],1);
5182            base[4]= Ct;
5183            vs_top=(vs_base=base+3)+2;
5184            (void) (*Lnk384)();
5185            vs_top=sup;
5186            V491= vs_base[0];
5187            V489= nconc((V486),V491);
5188            V490= structure_ref((V483),VV[224],4);
5189            if(!(type_of((V488))==t_symbol)){
5190            goto T1823;}
5191            base[3]= (V488);
5192            vs_top=(vs_base=base+3)+1;
5193            Lsymbol_function();
5194            vs_top=sup;
5195            V488= vs_base[0];
5196            goto T1823;
5197    T1823:;
5198            if(((V484))==Cnil){
5199            goto T1830;}
5200            base[3]= (V488);
5201            base[4]= (V479);
5202            base[5]= (V481);
5203            base[6]= (V489);
5204            base[7]= VV[239];
5205            base[8]= Ct;
5206            {object V492;
5207            V492= (V490);
5208             vs_top=base+9;
5209             while(!endp(V492))
5210             {vs_push(car(V492));V492=cdr(V492);}
5211            vs_base=base+4;}
5212            super_funcall_no_event(base[3]);
5213            vs_top=sup;
5214            V485= vs_base[0];
5215            goto T1828;
5216            goto T1830;
5217    T1830:;
5218            base[3]= (V488);
5219            base[4]= (V479);
5220            base[5]= (V481);
5221            base[6]= (V489);
5222            {object V493;
5223            V493= (V490);
5224             vs_top=base+7;
5225             while(!endp(V493))
5226             {vs_push(car(V493));V493=cdr(V493);}
5227            vs_base=base+4;}
5228            super_funcall_no_event(base[3]);
5229            vs_top=sup;
5230            V485= vs_base[0];
5231            goto T1828;
5232    T1828:;}
5233            if((symbol_value(VV[102]))==Cnil){
5234            goto T1844;}
5235            base[3]= VV[240];
5236            base[4]= symbol_value(VV[102]);
5237            vs_top=(vs_base=base+3)+2;
5238            (void) (*Lnk347)();
5239            vs_top=sup;
5240            goto T1844;
5241    T1844:;
5242            V495 = make_fixnum((long)length((V485)));
5243            {register object x= V495,V494= VV[241];
5244            while(!endp(V494))
5245            if(eql(x,V494->c.c_car)){
5246            goto T1849;
5247            }else V494=V494->c.c_cdr;}
5248            base[3]= VV[242];
5249            base[4]= (V482);
5250            vs_top=(vs_base=base+3)+2;
5251            (void) (*Lnk347)();
5252            vs_top=sup;
5253            goto T1849;
5254    T1849:;
5255            {register object V496;
5256            register object V497;
5257            V496= car((V485));
5258            V497= Cnil;
5259            goto T1857;
5260    T1857:;
5261            if(((V496))!=Cnil){
5262            goto T1858;}
5263            goto T1854;
5264            goto T1858;
5265    T1858:;
5266            V497= car((V496));
5267            if(!(type_of((V497))!=t_cons)){
5268            goto T1864;}
5269            base[3]= (V497);
5270            base[4]= Cnil;
5271            base[5]= Cnil;
5272            vs_top=(vs_base=base+3)+3;
5273            (void) (*Lnk380)();
5274            vs_top=sup;
5275            goto T1862;
5276            goto T1864;
5277    T1864:;
5278            base[3]= car((V497));
5279            base[4]= cadr((V497));
5280            base[5]= caddr((V497));
5281            vs_top=(vs_base=base+3)+3;
5282            (void) (*Lnk380)();
5283            vs_top=sup;
5284            goto T1862;
5285    T1862:;
5286            V496= cdr((V496));
5287            goto T1857;}
5288            goto T1854;
5289    T1854:;
5290            V498= reverse(cadr((V485)));
5291            setq(VV[106],nconc(/* INLINE-ARGS */V498,symbol_value(VV[106])));
5292            base[3]= cddr((V485));
5293            vs_top=(vs_base=base+3)+1;
5294            return;}
5295            }
5296    }
5297    /*      function definition for NAMED-VARIABLE  */
5298    
5299    static void L94()
5300    {register object *base=vs_base;
5301            register object *sup=base+VM82; VC82
5302            vs_reserve(VM82);
5303            {object V499;
5304            check_arg(1);
5305            V499=(base[0]);
5306            vs_top=sup;
5307            goto TTL;
5308    TTL:;
5309            {object V500;
5310            base[1]= (V499);
5311            base[2]= symbol_value(VV[102]);
5312            vs_top=(vs_base=base+1)+2;
5313            (void) (*Lnk385)();
5314            vs_top=sup;
5315            V500= vs_base[0];
5316            if(((V500))!=Cnil){
5317            goto T1882;}
5318            vs_base=vs_top;
5319            (void) (*Lnk327)();
5320            vs_top=sup;
5321            base[1]= vs_base[0];
5322            base[2]= Cnil;
5323            vs_top=(vs_base=base+1)+2;
5324            return;
5325            goto T1882;
5326    T1882:;
5327            setq(VV[102],(VFUN_NARGS=2,(*(LnkLI386))((V500),symbol_value(VV[102]))));
5328            base[1]= cdr((V500));
5329            base[2]= Ct;
5330            vs_top=(vs_base=base+1)+2;
5331            return;}
5332            }
5333    }
5334    /*      function definition for LOOP-COLLECT-PREPOSITIONAL-PHRASES      */
5335    
5336    static void L95()
5337    {register object *base=vs_base;
5338            register object *sup=base+VM83; VC83
5339            vs_reserve(VM83);
5340            {object V501;
5341            object V502;
5342            object V503;
5343            if(vs_top-vs_base<1) too_few_arguments();
5344            if(vs_top-vs_base>3) too_many_arguments();
5345            V501=(base[0]);
5346            vs_base=vs_base+1;
5347            if(vs_base>=vs_top){vs_top=sup;goto T1890;}
5348            V502=(base[1]);
5349            vs_base++;
5350            if(vs_base>=vs_top){vs_top=sup;goto T1891;}
5351            V503=(base[2]);
5352            vs_top=sup;
5353            goto T1892;
5354            goto T1890;
5355    T1890:;
5356            V502= Cnil;
5357            goto T1891;
5358    T1891:;
5359            V503= Cnil;
5360            goto T1892;
5361    T1892:;
5362            base[3]=make_cclosure_new(LC96,Cnil,Cnil,Cdata);
5363            base[3]=MMcons(base[3],Cnil);
5364            {object V504;
5365            object V505;
5366            register object V506;
5367            register object V507;
5368            object V508;
5369            object V509;
5370            {object V510;
5371            object V511= (V503);
5372            if(endp(V511)){
5373            V508= Cnil;
5374            goto T1895;}
5375            base[4]=V510=MMcons(Cnil,Cnil);
5376            goto T1896;
5377    T1896:;
5378            V513= car((V511->c.c_car));
5379            V514= (base[3]->c.c_car);
5380            base[5]= (VFUN_NARGS=4,(*(LnkLI368))(/* INLINE-ARGS */V513,(V501),VV[20],V514));
5381            vs_top=(vs_base=base+5)+1;
5382            Lcopy_list();
5383            vs_top=sup;
5384            (V510->c.c_cdr)= vs_base[0];
5385            {object cdr_V510=MMcdr(V510);while(!endp(cdr_V510)) {cdr_V510=MMcdr(cdr_V510);V510=MMcdr(V510);}}
5386            V511=MMcdr(V511);
5387            if(endp(V511)){
5388            base[4]=base[4]->c.c_cdr;
5389            V508= base[4];
5390            goto T1895;}
5391            goto T1896;}
5392            goto T1895;
5393    T1895:;
5394            {object V515;
5395            object V516= (V503);
5396            if(endp(V516)){
5397            V509= Cnil;
5398            goto T1900;}
5399            base[4]=V515=MMcons(Cnil,Cnil);
5400            goto T1901;
5401    T1901:;
5402            (V515->c.c_car)= car((V516->c.c_car));
5403            V516=MMcdr(V516);
5404            if(endp(V516)){
5405            V509= base[4];
5406            goto T1900;}
5407            V515=MMcdr(V515)=MMcons(Cnil,Cnil);
5408            goto T1901;}
5409            goto T1900;
5410    T1900:;
5411            V504= Cnil;
5412            V505= (V503);
5413            V506= Cnil;
5414            V507= Cnil;
5415            goto T1904;
5416    T1904:;
5417            if((symbol_value(VV[89]))!=Cnil){
5418            goto T1905;}
5419            base[4]= nreverse((V505));
5420            vs_top=(vs_base=base+4)+1;
5421            return;
5422            goto T1905;
5423    T1905:;
5424            V504= car(symbol_value(VV[89]));
5425            {register object V517;
5426            register object V518;
5427            V517= (V501);
5428            V518= car((V517));
5429            goto T1915;
5430    T1915:;
5431            if(!(endp_prop((V517)))){
5432            goto T1916;}
5433            goto T1911;
5434            goto T1916;
5435    T1916:;
5436            base[5]= (V504);
5437            base[6]= (V518);
5438            vs_top=(vs_base=base+5)+2;
5439            L96(base);
5440            vs_top=sup;
5441            V507= vs_base[0];
5442            if(((V507))==Cnil){
5443            goto T1920;}
5444            V506= (V518);
5445            goto T1911;
5446            goto T1920;
5447    T1920:;
5448            V517= cdr((V517));
5449            V518= car((V517));
5450            goto T1915;}
5451            goto T1911;
5452    T1911:;
5453            if(((V506))==Cnil){
5454            goto T1934;}
5455            {register object x= (V507),V519= (V508);
5456            while(!endp(V519))
5457            if(eql(x,V519->c.c_car)){
5458            goto T1938;
5459            }else V519=V519->c.c_cdr;
5460            goto T1936;}
5461            goto T1938;
5462    T1938:;
5463            {register object x= (V507),V520= (V509);
5464            while(!endp(V520))
5465            if(eql(x,V520->c.c_car)){
5466            goto T1942;
5467            }else V520=V520->c.c_cdr;
5468            goto T1941;}
5469            goto T1942;
5470    T1942:;
5471            base[4]= VV[243];
5472            goto T1939;
5473            goto T1941;
5474    T1941:;
5475            base[4]= VV[244];
5476            goto T1939;
5477    T1939:;
5478            base[5]= (V504);
5479            vs_top=(vs_base=base+4)+2;
5480            (void) (*Lnk347)();
5481            vs_top=sup;
5482            goto T1936;
5483    T1936:;
5484            if(!(type_of((V506))==t_cons||((V506))==Cnil)){
5485            goto T1947;}
5486            V509= append((V506),(V509));
5487            goto T1945;
5488            goto T1947;
5489    T1947:;
5490            V509= make_cons((V506),(V509));
5491            goto T1945;
5492    T1945:;
5493            vs_base=vs_top;
5494            (void) (*Lnk350)();
5495            vs_top=sup;
5496            {object V521;
5497            vs_base=vs_top;
5498            (void) (*Lnk361)();
5499            vs_top=sup;
5500            V522= vs_base[0];
5501            V521= list(2,(V507),V522);
5502            V505= make_cons((V521),(V505));
5503            goto T1932;}
5504            goto T1934;
5505    T1934:;
5506            if(((V502))==Cnil){
5507            goto T1954;}
5508            base[4]= (V504);
5509            base[5]= VV[245];
5510            vs_top=(vs_base=base+4)+2;
5511            (void) (*Lnk357)();
5512            vs_top=sup;
5513            if((vs_base[0])==Cnil){
5514            goto T1954;}
5515            vs_base=vs_top;
5516            (void) (*Lnk350)();
5517            vs_top=sup;
5518            {register object V523;
5519            object V524;
5520            vs_base=vs_top;
5521            (void) (*Lnk350)();
5522            vs_top=sup;
5523            V523= vs_base[0];
5524            V524= Cnil;
5525            goto T1963;
5526    T1963:;
5527            if(type_of((V523))!=t_cons){
5528            goto T1967;}
5529            if(type_of(cdr((V523)))!=t_cons){
5530            goto T1967;}
5531            if((cddr((V523)))!=Cnil){
5532            goto T1967;}
5533            if(!(type_of(car((V523)))==t_symbol)){
5534            goto T1967;}
5535            if((cadr((V523)))==Cnil){
5536            goto T1966;}
5537            if(type_of(cadr((V523)))==t_symbol){
5538            goto T1966;}
5539            goto T1967;
5540    T1967:;
5541            base[4]= VV[246];
5542            base[5]= (V523);
5543            vs_top=(vs_base=base+4)+2;
5544            (void) (*Lnk347)();
5545            vs_top=sup;
5546            goto T1966;
5547    T1966:;
5548            if((cadr((V523)))==Cnil){
5549            goto T1981;}
5550            base[4]= car((V523));
5551            base[5]= symbol_value(VV[102]);
5552            vs_top=(vs_base=base+4)+2;
5553            (void) (*Lnk385)();
5554            vs_top=sup;
5555            V524= vs_base[0];
5556            if(((V524))==Cnil){
5557            goto T1985;}
5558            base[4]= VV[247];
5559            base[5]= car((V523));
5560            base[6]= cadr((V523));
5561            base[7]= cadr((V524));
5562            vs_top=(vs_base=base+4)+4;
5563            (void) (*Lnk347)();
5564            vs_top=sup;
5565            goto T1981;
5566            goto T1985;
5567    T1985:;
5568            {object V525;
5569            V525= make_cons(car((V523)),cadr((V523)));
5570            setq(VV[102],make_cons((V525),symbol_value(VV[102])));}
5571            goto T1981;
5572    T1981:;
5573            if((symbol_value(VV[89]))==Cnil){
5574            goto T1997;}
5575            if(!(type_of(car(symbol_value(VV[89])))==t_symbol)){
5576            goto T1996;}
5577            goto T1997;
5578    T1997:;
5579            goto T1932;
5580            goto T1996;
5581    T1996:;
5582            vs_base=vs_top;
5583            (void) (*Lnk350)();
5584            vs_top=sup;
5585            V523= vs_base[0];
5586            goto T1963;}
5587            goto T1954;
5588    T1954:;
5589            base[4]= nreverse((V505));
5590            vs_top=(vs_base=base+4)+1;
5591            return;
5592            goto T1932;
5593    T1932:;
5594            V506= Cnil;
5595            V507= Cnil;
5596            goto T1904;}
5597            }
5598    }
5599    /*      function definition for LOOP-SEQUENCER  */
5600    
5601    static void L97()
5602    {register object *base=vs_base;
5603            register object *sup=base+VM84; VC84
5604            vs_reserve(VM84);
5605            {object V526;
5606            register object V527;
5607            object V528;
5608            object V529;
5609            object V530;
5610            object V531;
5611            object V532;
5612            object V533;
5613            object V534;
5614            object V535;
5615            check_arg(10);
5616            V526=(base[0]);
5617            V527=(base[1]);
5618            V528=(base[2]);
5619            V529=(base[3]);
5620            V530=(base[4]);
5621            V531=(base[5]);
5622            V532=(base[6]);
5623            V533=(base[7]);
5624            V534=(base[8]);
5625            V535=(base[9]);
5626            vs_top=sup;
5627            goto TTL;
5628    TTL:;
5629            {object V536;
5630            object V537;
5631            object V538;
5632            object V539;
5633            object V540;
5634            object V541;
5635            object V542;
5636            register object V543;
5637            register object V544;
5638            object V545;
5639            object V546;
5640            object V547;
5641            object V548;
5642            object V549;
5643            object V550;{object V552;
5644            base[10]= (V527);
5645            vs_top=(vs_base=base+10)+1;
5646            (void) (*Lnk329)();
5647            vs_top=sup;
5648            V552= vs_base[0];
5649            if(V552==Cnil)goto T2010;
5650            V551= V552;
5651            goto T2009;
5652            goto T2010;
5653    T2010:;}
5654            V551= small_fixnum(0);
5655            goto T2009;
5656    T2009:;
5657            V540= one_plus(V551);
5658            V536= Cnil;
5659            V537= Cnil;
5660            V538= Cnil;
5661            V539= Cnil;
5662            V541= Ct;
5663            V542= Cnil;
5664            V543= Cnil;
5665            V544= Cnil;
5666            V545= Cnil;
5667            V546= Cnil;
5668            V547= Cnil;
5669            V548= Cnil;
5670            V549= Cnil;
5671            V550= Cnil;
5672            if(((V529))==Cnil){
5673            goto T2013;}
5674            base[10]= (V529);
5675            base[11]= Cnil;
5676            base[12]= (V530);
5677            vs_top=(vs_base=base+10)+3;
5678            (void) (*Lnk380)();
5679            vs_top=sup;
5680            goto T2013;
5681    T2013:;
5682            {register object V553;
5683            register object V554;
5684            register object V555;
5685            object V556;
5686            V553= (V535);
5687            V554= Cnil;
5688            V555= Cnil;
5689            V556= Cnil;
5690            goto T2021;
5691    T2021:;
5692            if(((V553))!=Cnil){
5693            goto T2022;}
5694            goto T2019;
5695            goto T2022;
5696    T2022:;
5697            V554= caar((V553));
5698            V555= cadar((V553));
5699            {object V557= (V554);
5700            if((V557!= VV[387])
5701            && (V557!= VV[234]))goto T2031;
5702            V537= Ct;
5703            base[10]= (V531);
5704            base[11]= (V555);
5705            base[12]= (V532);
5706            vs_top=(vs_base=base+10)+3;
5707            (void) (*Lnk359)();
5708            vs_top=sup;
5709            goto T2030;
5710            goto T2031;
5711    T2031:;
5712            if((V557!= VV[388])
5713            && (V557!= VV[248])
5714            && (V557!= VV[250]))goto T2037;
5715            V545= Ct;
5716            if(!(((V554))==(VV[248]))){
5717            goto T2042;}
5718            V543= VV[249];
5719            goto T2040;
5720            goto T2042;
5721    T2042:;
5722            if(!(((V554))==(VV[250]))){
5723            goto T2040;}
5724            V543= VV[251];
5725            goto T2040;
5726    T2040:;
5727            base[10]= (V555);
5728            base[11]= (V527);
5729            vs_top=(vs_base=base+10)+2;
5730            (void) (*Lnk379)();
5731            if(vs_base<vs_top){
5732            V555= vs_base[0];
5733            vs_base++;
5734            }else{
5735            V555= Cnil;}
5736            if(vs_base<vs_top){
5737            V547= vs_base[0];
5738            vs_base++;
5739            }else{
5740            V547= Cnil;}
5741            if(vs_base<vs_top){
5742            V546= vs_base[0];
5743            }else{
5744            V546= Cnil;}
5745            vs_top=sup;
5746            base[10]= (V526);
5747            base[11]= (V555);
5748            base[12]= (V527);
5749            vs_top=(vs_base=base+10)+3;
5750            (void) (*Lnk380)();
5751            vs_top=sup;
5752            goto T2030;
5753            goto T2037;
5754    T2037:;
5755            if((V557!= VV[252])
5756            && (V557!= VV[253])
5757            && (V557!= VV[254])
5758            && (V557!= VV[255])
5759            && (V557!= VV[256]))goto T2055;
5760            base[10]= (V554);
5761            base[11]= VV[252];
5762            vs_top=(vs_base=base+10)+2;
5763            (void) (*Lnk357)();
5764            vs_top=sup;
5765            if((vs_base[0])==Cnil){
5766            goto T2058;}
5767            V543= VV[251];
5768            V544= VV[251];
5769            goto T2056;
5770            goto T2058;
5771    T2058:;
5772            base[10]= (V554);
5773            base[11]= VV[253];
5774            vs_top=(vs_base=base+10)+2;
5775            (void) (*Lnk357)();
5776            vs_top=sup;
5777            if((vs_base[0])==Cnil){
5778            goto T2065;}
5779            V544= Ct;
5780            goto T2056;
5781            goto T2065;
5782    T2065:;
5783            base[10]= (V554);
5784            base[11]= VV[254];
5785            vs_top=(vs_base=base+10)+2;
5786            (void) (*Lnk357)();
5787            vs_top=sup;
5788            if((vs_base[0])==Cnil){
5789            goto T2071;}
5790            V543= VV[249];
5791            V544= VV[249];
5792            goto T2056;
5793            goto T2071;
5794    T2071:;
5795            base[10]= (V554);
5796            base[11]= VV[255];
5797            vs_top=(vs_base=base+10)+2;
5798            (void) (*Lnk357)();
5799            vs_top=sup;
5800            if((vs_base[0])==Cnil){
5801            goto T2078;}
5802            V543= VV[249];
5803            goto T2056;
5804            goto T2078;
5805    T2078:;
5806            base[10]= (V554);
5807            base[11]= VV[256];
5808            vs_top=(vs_base=base+10)+2;
5809            (void) (*Lnk357)();
5810            vs_top=sup;
5811            if((vs_base[0])==Cnil){
5812            goto T2056;}
5813            V543= VV[251];
5814            goto T2056;
5815    T2056:;
5816            V548= Ct;
5817            base[10]= (V555);
5818            base[11]= (V527);
5819            vs_top=(vs_base=base+10)+2;
5820            (void) (*Lnk379)();
5821            if(vs_base<vs_top){
5822            V555= vs_base[0];
5823            vs_base++;
5824            }else{
5825            V555= Cnil;}
5826            if(vs_base<vs_top){
5827            V549= vs_base[0];
5828            vs_base++;
5829            }else{
5830            V549= Cnil;}
5831            if(vs_base<vs_top){
5832            V550= vs_base[0];
5833            }else{
5834            V550= Cnil;}
5835            vs_top=sup;
5836            if(((V549))==Cnil){
5837            goto T2096;}
5838            V536= list(2,VV[217],(V550));
5839            goto T2094;
5840            goto T2096;
5841    T2096:;
5842            base[11]= VV[257];
5843            vs_top=(vs_base=base+11)+1;
5844            (void) (*Lnk327)();
5845            vs_top=sup;
5846            base[10]= vs_base[0];
5847            base[11]= (V555);
5848            base[12]= (V527);
5849            vs_top=(vs_base=base+10)+3;
5850            (void) (*Lnk359)();
5851            vs_top=sup;
5852            V536= vs_base[0];
5853            goto T2094;
5854    T2094:;
5855            goto T2030;
5856            goto T2055;
5857    T2055:;
5858            if((V557!= VV[215]))goto T2102;
5859            base[10]= (V555);
5860            base[11]= (V527);
5861            vs_top=(vs_base=base+10)+2;
5862            (void) (*Lnk379)();
5863            if(vs_base<vs_top){
5864            V555= vs_base[0];
5865            vs_base++;
5866            }else{
5867            V555= Cnil;}
5868            if(vs_base<vs_top){
5869            V541= vs_base[0];
5870            vs_base++;
5871            }else{
5872            V541= Cnil;}
5873            if(vs_base<vs_top){
5874            V540= vs_base[0];
5875            }else{
5876            V540= Cnil;}
5877            vs_top=sup;
5878            if(((V541))!=Cnil){
5879            goto T2030;}
5880            base[11]= VV[258];
5881            vs_top=(vs_base=base+11)+1;
5882            (void) (*Lnk327)();
5883            vs_top=sup;
5884            V540= vs_base[0];
5885            base[10]= (V540);
5886            base[11]= (V555);
5887            base[12]= (V527);
5888            vs_top=(vs_base=base+10)+3;
5889            (void) (*Lnk359)();
5890            vs_top=sup;
5891            goto T2030;
5892            goto T2102;
5893    T2102:;
5894            base[10]= VV[259];
5895            base[11]= (V554);
5896            vs_top=(vs_base=base+10)+2;
5897            (void) (*Lnk347)();
5898            vs_top=sup;}
5899            goto T2030;
5900    T2030:;
5901            if(((V556))==Cnil){
5902            goto T2116;}
5903            if(((V543))==Cnil){
5904            goto T2116;}
5905            if(((V543))==((V556))){
5906            goto T2116;}
5907            base[10]= VV[260];
5908            vs_top=(vs_base=base+10)+1;
5909            (void) (*Lnk347)();
5910            vs_top=sup;
5911            goto T2116;
5912    T2116:;
5913            V556= (V543);
5914            V553= cdr((V553));
5915            goto T2021;}
5916            goto T2019;
5917    T2019:;
5918            if(((V531))==Cnil){
5919            goto T2129;}
5920            if(((V537))!=Cnil){
5921            goto T2129;}
5922            base[10]= VV[261];
5923            vs_top=(vs_base=base+10)+1;
5924            (void) (*Lnk347)();
5925            vs_top=sup;
5926            goto T2129;
5927    T2129:;
5928            if(((V545))!=Cnil){
5929            goto T2135;}
5930            base[10]= (V526);
5931            V547= Ct;{object V558;
5932            base[12]= (V527);
5933            vs_top=(vs_base=base+12)+1;
5934            (void) (*Lnk329)();
5935            vs_top=sup;
5936            V558= vs_base[0];
5937            if(V558==Cnil)goto T2143;
5938            V546= V558;
5939            goto T2142;
5940            goto T2143;
5941    T2143:;}
5942            V546= small_fixnum(0);
5943            goto T2142;
5944    T2142:;
5945            base[11]= (V546);
5946            base[12]= (V527);
5947            vs_top=(vs_base=base+10)+3;
5948            (void) (*Lnk380)();
5949            vs_top=sup;
5950            goto T2135;
5951    T2135:;
5952            {register object x= (V543),V559= VV[262];
5953            while(!endp(V559))
5954            if(eql(x,V559->c.c_car)){
5955            goto T2150;
5956            }else V559=V559->c.c_cdr;
5957            goto T2149;}
5958            goto T2150;
5959    T2150:;
5960            if(((V548))!=Cnil){
5961            goto T2152;}
5962            if(((V534))==Cnil){
5963            goto T2151;}
5964            goto T2152;
5965    T2152:;
5966            if(((V548))!=Cnil){
5967            goto T2156;}
5968            base[11]= VV[263];
5969            vs_top=(vs_base=base+11)+1;
5970            (void) (*Lnk327)();
5971            vs_top=sup;
5972            V536= vs_base[0];
5973            base[10]= (V536);
5974            base[11]= Cnil;
5975            base[12]= (V527);
5976            vs_top=(vs_base=base+10)+3;
5977            (void) (*Lnk359)();
5978            vs_top=sup;
5979            {object V560;
5980            V560= list(3,VV[11],(V536),(V534));
5981            setq(VV[106],make_cons((V560),symbol_value(VV[106])));}
5982            goto T2156;
5983    T2156:;
5984            if(((V544))==Cnil){
5985            goto T2169;}
5986            V538= VV[34];
5987            goto T2167;
5988            goto T2169;
5989    T2169:;
5990            V538= VV[213];
5991            goto T2167;
5992    T2167:;
5993            goto T2151;
5994    T2151:;
5995            if(!(eql((V540),small_fixnum(1)))){
5996            goto T2173;}
5997            V542= list(2,VV[180],(V526));
5998            goto T2171;
5999            goto T2173;
6000    T2173:;
6001            V542= list(3,VV[181],(V526),(V540));
6002            goto T2171;
6003    T2171:;
6004            goto T2147;
6005            goto T2149;
6006    T2149:;
6007            if(((V545))!=Cnil){
6008            goto T2175;}
6009            if(((V534))!=Cnil){
6010            goto T2178;}
6011            base[10]= VV[264];
6012            vs_top=(vs_base=base+10)+1;
6013            (void) (*Lnk347)();
6014            vs_top=sup;
6015            goto T2178;
6016    T2178:;
6017            {object V561;
6018            V561= list(3,VV[11],(V526),list(2,VV[199],(V534)));
6019            setq(VV[106],make_cons((V561),symbol_value(VV[106])));}
6020            goto T2175;
6021    T2175:;
6022            if(((V534))==Cnil){
6023            goto T2184;}
6024            if(((V536))!=Cnil){
6025            goto T2184;}
6026            base[10]= (V527);
6027            vs_top=(vs_base=base+10)+1;
6028            (void) (*Lnk329)();
6029            vs_top=sup;
6030            V536= vs_base[0];
6031            V544= Ct;
6032            goto T2184;
6033    T2184:;
6034            if(((V536))==Cnil){
6035            goto T2193;}
6036            if(((V544))==Cnil){
6037            goto T2198;}
6038            V538= VV[33];
6039            goto T2196;
6040            goto T2198;
6041    T2198:;
6042            V538= VV[265];
6043            goto T2196;
6044    T2196:;
6045            goto T2193;
6046    T2193:;
6047            if(!(eql((V540),small_fixnum(1)))){
6048            goto T2202;}
6049            V542= list(2,VV[199],(V526));
6050            goto T2200;
6051            goto T2202;
6052    T2202:;
6053            V542= list(3,VV[266],(V526),(V540));
6054            goto T2200;
6055    T2200:;
6056            goto T2147;
6057    T2147:;
6058            if(((V538))==Cnil){
6059            goto T2204;}
6060            base[10]= Ct;
6061            base[11]= (V526);
6062            base[12]= list(3,(V538),(V526),(V536));
6063            vs_top=(vs_base=base+10)+3;
6064            (void) (*Lnk331)();
6065            vs_top=sup;
6066            V539= vs_base[0];
6067            goto T2204;
6068    T2204:;
6069            if(((V533))==Cnil){
6070            goto T2211;}
6071            base[10]= (V528);
6072            base[11]= (V526);
6073            base[12]= (V533);
6074            vs_top=(vs_base=base+10)+3;
6075            (void) (*Lnk331)();
6076            vs_top=sup;
6077            V562= vs_base[0];
6078            V533= list(2,(V529),V562);
6079            goto T2211;
6080    T2211:;
6081            {object V563;
6082            object V564;
6083            V563= (V539);
6084            V564= (V539);
6085            if(((V541))==Cnil){
6086            goto T2219;}
6087            if(((V547))==Cnil){
6088            goto T2219;}
6089            if(((V549))==Cnil){
6090            goto T2219;}
6091            base[10]= (V538);
6092            vs_top=(vs_base=base+10)+1;
6093            Lsymbol_function();
6094            vs_top=sup;
6095            V565= vs_base[0];
6096            V563= (
6097            V566 = V565,
6098            (type_of(V566) == t_sfun ?(*((V566)->sfn.sfn_self)):
6099            (fcall.fun=(V566),fcall.argd=2,fcalln))((V546),(V550)));
6100            if(((V563))==Cnil){
6101            goto T2219;}
6102            V564= Ct;
6103            goto T2219;
6104    T2219:;
6105            base[10]= Ct;
6106            base[11]= (V526);
6107            base[12]= (V542);
6108            vs_top=(vs_base=base+10)+3;
6109            (void) (*Lnk331)();
6110            vs_top=sup;
6111            V567= vs_base[0];
6112            base[10]= list(8,Cnil,list(2,(V526),V567),(V564),(V533),Cnil,Cnil,(V563),(V533));
6113            vs_top=(vs_base=base+10)+1;
6114            return;}}
6115            }
6116    }
6117    /*      function definition for LOOP-FOR-ARITHMETIC     */
6118    
6119    static void L98()
6120    {register object *base=vs_base;
6121            register object *sup=base+VM85; VC85
6122            vs_reserve(VM85);
6123            {object V568;
6124            object V569;
6125            object V570;
6126            object V571;
6127            check_arg(4);
6128            V568=(base[0]);
6129            V569=(base[1]);
6130            V570=(base[2]);
6131            V571=(base[3]);
6132            vs_top=sup;
6133            goto TTL;
6134    TTL:;
6135            base[4]= (V568);
6136            base[6]= (V570);
6137            base[7]= symbol_value(VV[183]);
6138            vs_top=(vs_base=base+6)+2;
6139            (void) (*Lnk375)();
6140            vs_top=sup;
6141            base[5]= vs_base[0];
6142            base[6]= Ct;
6143            base[7]= Cnil;
6144            base[8]= Cnil;
6145            base[9]= Cnil;
6146            base[10]= Cnil;
6147            base[11]= Cnil;
6148            base[12]= Cnil;
6149            base[14]= VV[267];
6150            base[15]= Cnil;
6151            V572= list(2,(V571),(V569));
6152            base[16]= make_cons(/* INLINE-ARGS */V572,Cnil);
6153            vs_top=(vs_base=base+14)+3;
6154            (void) (*Lnk384)();
6155            vs_top=sup;
6156            base[13]= vs_base[0];
6157            vs_top=(vs_base=base+4)+10;
6158            (void) (*Lnk389)();
6159            return;
6160            }
6161    }
6162    /*      function definition for LOOP-SEQUENCE-ELEMENTS-PATH     */
6163    
6164    static void L99()
6165    {register object *base=vs_base;
6166            register object *sup=base+VM86; VC86
6167            vs_reserve(VM86);
6168            {object V573;
6169            object V574;
6170            object V575;
6171            object V576;
6172            object V577;
6173            object V578;
6174            object V579;
6175            if(vs_top-vs_base<3) too_few_arguments();
6176            parse_key(vs_base+3,FALSE,FALSE,4,VV[390],VV[391],VV[392],VV[393]);
6177            V573=(base[0]);
6178            V574=(base[1]);
6179            V575=(base[2]);
6180            vs_top=sup;
6181            V576=(base[3]);
6182            V577=(base[4]);
6183            V578=(base[5]);
6184            V579=(base[6]);
6185            {object V580;
6186            object V581;
6187            base[11]= VV[268];
6188            vs_top=(vs_base=base+11)+1;
6189            (void) (*Lnk394)();
6190            if(vs_base>=vs_top){vs_top=sup;goto T2253;}
6191            V580= vs_base[0];
6192            vs_base++;
6193            if(vs_base>=vs_top){vs_top=sup;goto T2254;}
6194            V581= vs_base[0];
6195            vs_top=sup;
6196            goto T2255;
6197            goto T2253;
6198    T2253:;
6199            V580= Cnil;
6200            goto T2254;
6201    T2254:;
6202            V581= Cnil;
6203            goto T2255;
6204    T2255:;
6205            {object V582;
6206            base[11]= VV[269];
6207            vs_top=(vs_base=base+11)+1;
6208            (void) (*Lnk394)();
6209            vs_top=sup;
6210            V582= vs_base[0];
6211            base[11]= (V580);
6212            base[12]= VV[210];
6213            base[13]= (V581);
6214            base[14]= (V573);
6215            if((V574)!=Cnil){
6216            base[15]= (V574);
6217            goto T2263;}
6218            base[15]= (V579);
6219            goto T2263;
6220    T2263:;
6221            base[16]= (V582);
6222            base[17]= (V578);
6223            base[18]= list(3,(V576),(V582),(V580));
6224            base[19]= list(2,(V577),(V582));
6225            base[20]= (V575);
6226            vs_top=(vs_base=base+11)+10;
6227            (void) (*Lnk389)();
6228            vs_top=sup;
6229            V583= vs_base[0];
6230            base[11]= listA(3,Cnil,Cnil,V583);
6231            vs_top=(vs_base=base+11)+1;
6232            return;}}
6233            }
6234    }
6235    /*      function definition for LOOP-HASH-TABLE-ITERATION-PATH  */
6236    
6237    static void L100()
6238    {register object *base=vs_base;
6239            register object *sup=base+VM87; VC87
6240            vs_reserve(VM87);
6241            bds_check;
6242            {object V584;
6243            object V585;
6244            object V586;
6245            register object V587;
6246            if(vs_top-vs_base<3) too_few_arguments();
6247            parse_key(vs_base+3,FALSE,FALSE,1,VV[395]);
6248            V584=(base[0]);
6249            V585=(base[1]);
6250            V586=(base[2]);
6251            vs_top=sup;
6252            V587=(base[3]);
6253            bds_bind(VV[44],small_fixnum(4));
6254            bds_bind(VV[45],small_fixnum(4));
6255            goto T2271;
6256    T2271:;
6257            base[7]= (V587);
6258            base[8]= VV[270];
6259            vs_top=(vs_base=base+7)+2;
6260            (void) (*Lnk333)();
6261            vs_top=sup;
6262            if((vs_base[0])==Cnil){
6263            goto T2272;}
6264            bds_unwind1;
6265            bds_unwind1;
6266            goto T2269;
6267            goto T2272;
6268    T2272:;
6269            base[7]= VV[47];
6270            base[8]= VV[48];
6271            base[9]= VV[271];
6272            base[10]= (V587);
6273            base[11]= VV[270];
6274            vs_top=(vs_base=base+7)+5;
6275            Lcerror();
6276            vs_top=sup;
6277            base[7]= symbol_value(VV[50]);
6278            base[8]= VV[51];
6279            base[9]= VV[271];
6280            vs_top=(vs_base=base+7)+3;
6281            Lformat();
6282            vs_top=sup;
6283            base[7]= symbol_value(VV[50]);
6284            vs_top=(vs_base=base+7)+1;
6285            Lfinish_output();
6286            vs_top=sup;
6287            vs_base=vs_top;
6288            Lread();
6289            vs_top=sup;
6290            V587= vs_base[0];
6291            base[7]= symbol_value(VV[50]);
6292            base[8]= VV[52];
6293            vs_top=(vs_base=base+7)+2;
6294            Lformat();
6295            vs_top=sup;
6296            goto T2271;
6297            goto T2269;
6298    T2269:;
6299            if((cdr((V586)))!=Cnil){
6300            goto T2298;}
6301            {register object x= caar((V586)),V588= VV[272];
6302            while(!endp(V588))
6303            if(eql(x,V588->c.c_car)){
6304            goto T2299;
6305            }else V588=V588->c.c_cdr;}
6306            goto T2298;
6307    T2298:;
6308            base[5]= VV[273];
6309            vs_top=(vs_base=base+5)+1;
6310            (void) (*Lnk347)();
6311            vs_top=sup;
6312            goto T2297;
6313            goto T2299;
6314    T2299:;
6315            if(((V586))!=Cnil){
6316            goto T2297;}
6317            base[5]= VV[274];
6318            vs_top=(vs_base=base+5)+1;
6319            (void) (*Lnk347)();
6320            vs_top=sup;
6321            goto T2297;
6322    T2297:;
6323            {object V589;
6324            object V590;
6325            object V591;
6326            register object V592;
6327            base[5]= VV[275];
6328            vs_top=(vs_base=base+5)+1;
6329            (void) (*Lnk327)();
6330            vs_top=sup;
6331            V589= vs_base[0];
6332            base[5]= VV[276];
6333            vs_top=(vs_base=base+5)+1;
6334            (void) (*Lnk327)();
6335            vs_top=sup;
6336            V590= vs_base[0];
6337            V591= Cnil;
6338            V592= Cnil;
6339            {object V593;
6340            object V594;
6341            if(!(((V587))==(VV[277]))){
6342            goto T2314;}
6343            base[5]= VV[278];
6344            goto T2312;
6345            goto T2314;
6346    T2314:;
6347            base[5]= VV[277];
6348            goto T2312;
6349    T2312:;
6350            vs_top=(vs_base=base+5)+1;
6351            (void) (*Lnk394)();
6352            if(vs_base>=vs_top){vs_top=sup;goto T2316;}
6353            V593= vs_base[0];
6354            vs_base++;
6355            if(vs_base>=vs_top){vs_top=sup;goto T2317;}
6356            V594= vs_base[0];
6357            vs_top=sup;
6358            goto T2318;
6359            goto T2316;
6360    T2316:;
6361            V593= Cnil;
6362            goto T2317;
6363    T2317:;
6364            V594= Cnil;
6365            goto T2318;
6366    T2318:;
6367            V594= Ct;
6368            vs_base=vs_top;
6369            (void) (*Lnk378)();
6370            vs_top=sup;
6371            V591= vs_base[0];
6372            {register object V595;
6373            register object V596;
6374            register object V597;
6375            V598= list(3,(V584),Cnil,(V585));
6376            V599= list(2,(V589),cadar((V586)));
6377            if((V594)==Cnil){
6378            V600= Cnil;
6379            goto T2324;}
6380            if((V593)==Cnil){
6381            V600= Cnil;
6382            goto T2324;}
6383            V601= list(2,(V593),Cnil);
6384            V600= make_cons(/* INLINE-ARGS */V601,Cnil);
6385            goto T2324;
6386    T2324:;
6387            V597= listA(3,/* INLINE-ARGS */V598,/* INLINE-ARGS */V599,V600);
6388            V595= Cnil;
6389            V596= Cnil;
6390            if(!(((V587))==(VV[277]))){
6391            goto T2327;}
6392            V595= (V584);
6393            if((V594)==Cnil){
6394            V596= Cnil;
6395            goto T2331;}
6396            V596= (V593);
6397            goto T2331;
6398    T2331:;
6399            goto T2325;
6400            goto T2327;
6401    T2327:;
6402            if((V594)==Cnil){
6403            V595= Cnil;
6404            goto T2333;}
6405            V595= (V593);
6406            goto T2333;
6407    T2333:;
6408            V596= (V584);
6409            goto T2325;
6410    T2325:;
6411            {object V602;
6412            V602= list(2,VV[279],list(2,(V590),(V589)));
6413            setq(VV[107],make_cons((V602),symbol_value(VV[107])));}
6414            if(!(type_of((V595))==t_cons)){
6415            goto T2338;}{object V603;
6416            V603= (V595);
6417            base[5]= VV[280];
6418            vs_top=(vs_base=base+5)+1;
6419            (void) (*Lnk327)();
6420            vs_top=sup;
6421            V595= vs_base[0];
6422            V592= listA(3,V603,(V595),(V592));}
6423            {object V604;
6424            V604= list(2,(V595),Cnil);
6425            V597= make_cons((V604),(V597));}
6426            goto T2338;
6427    T2338:;
6428            if(!(type_of((V596))==t_cons)){
6429            goto T2347;}{object V605;
6430            V605= (V596);
6431            base[5]= VV[281];
6432            vs_top=(vs_base=base+5)+1;
6433            (void) (*Lnk327)();
6434            vs_top=sup;
6435            V596= vs_base[0];
6436            V592= listA(3,V605,(V596),(V592));}
6437            {object V606;
6438            V606= list(2,(V596),Cnil);
6439            V597= make_cons((V606),(V597));}
6440            goto T2347;
6441    T2347:;
6442            V607= list(3,(V591),(V595),(V596));
6443            base[5]= list(6,(V597),Cnil,Cnil,Cnil,list(2,VV[36],list(3,VV[85],/* INLINE-ARGS */V607,make_cons((V590),Cnil))),(V592));
6444            vs_top=(vs_base=base+5)+1;
6445            return;}}}
6446            }
6447    }
6448    /*      function definition for LOOP-PACKAGE-SYMBOLS-ITERATION-PATH     */
6449    
6450    static void L101()
6451    {register object *base=vs_base;
6452            register object *sup=base+VM88; VC88
6453            vs_reserve(VM88);
6454            {object V608;
6455            object V609;
6456            register object V610;
6457            object V611;
6458            if(vs_top-vs_base<3) too_few_arguments();
6459            parse_key(vs_base+3,FALSE,FALSE,1,VV[396]);
6460            V608=(base[0]);
6461            V609=(base[1]);
6462            V610=(base[2]);
6463            vs_top=sup;
6464            V611=(base[3]);
6465            if((cdr((V610)))!=Cnil){
6466            goto T2357;}
6467            {register object x= caar((V610)),V612= VV[282];
6468            while(!endp(V612))
6469            if(eql(x,V612->c.c_car)){
6470            goto T2358;
6471            }else V612=V612->c.c_cdr;}
6472            goto T2357;
6473    T2357:;
6474            base[5]= VV[283];
6475            vs_top=(vs_base=base+5)+1;
6476            (void) (*Lnk347)();
6477            vs_top=sup;
6478            goto T2356;
6479            goto T2358;
6480    T2358:;
6481            if(((V610))!=Cnil){
6482            goto T2356;}
6483            base[5]= VV[284];
6484            vs_top=(vs_base=base+5)+1;
6485            (void) (*Lnk347)();
6486            vs_top=sup;
6487            goto T2356;
6488    T2356:;
6489            if(type_of((V608))==t_symbol){
6490            goto T2366;}
6491            base[5]= VV[285];
6492            vs_top=(vs_base=base+5)+1;
6493            (void) (*Lnk347)();
6494            vs_top=sup;
6495            goto T2366;
6496    T2366:;
6497            {object V613;
6498            object V614;
6499            base[5]= VV[286];
6500            vs_top=(vs_base=base+5)+1;
6501            (void) (*Lnk327)();
6502            vs_top=sup;
6503            V613= vs_base[0];
6504            base[5]= VV[287];
6505            vs_top=(vs_base=base+5)+1;
6506            (void) (*Lnk327)();
6507            vs_top=sup;
6508            V614= vs_base[0];
6509            {object V615;
6510            V615= list(2,VV[288],listA(3,(V614),(V613),(V611)));
6511            setq(VV[107],make_cons((V615),symbol_value(VV[107])));}
6512            V616= list(3,(V608),Cnil,(V609));
6513            V617= list(2,/* INLINE-ARGS */V616,list(2,(V613),cadar((V610))));
6514            vs_base=vs_top;
6515            (void) (*Lnk378)();
6516            vs_top=sup;
6517            V618= vs_base[0];
6518            V619= list(2,V618,(V608));
6519            base[5]= list(6,/* INLINE-ARGS */V617,Cnil,Cnil,Cnil,list(2,VV[36],list(3,VV[85],/* INLINE-ARGS */V619,make_cons((V614),Cnil))),Cnil);
6520            vs_top=(vs_base=base+5)+1;
6521            return;}
6522            }
6523    }
6524    /*      function definition for MAKE-ANSI-LOOP-UNIVERSE */
6525    
6526    static void L102()
6527    {register object *base=vs_base;
6528            register object *sup=base+VM89; VC89
6529            vs_reserve(VM89);
6530            {object V620;
6531            check_arg(1);
6532            V620=(base[0]);
6533            vs_top=sup;
6534            goto TTL;
6535    TTL:;
6536            {register object V621;
6537            base[1]= VV[53];
6538            base[3]= VV[289];
6539            base[4]= VV[290];
6540            base[5]= VV[291];
6541            base[6]= VV[292];
6542            base[7]= VV[293];
6543            base[8]= VV[294];
6544            base[9]= VV[295];
6545            base[10]= VV[296];
6546            base[11]= VV[297];
6547            base[12]= VV[298];
6548            base[13]= VV[299];
6549            base[14]= VV[300];
6550            base[15]= list(2,VV[179],list(4,VV[301],VV[179],symbol_value(VV[183]),VV[210]));
6551            base[16]= list(2,VV[302],list(4,VV[301],VV[179],symbol_value(VV[183]),VV[210]));
6552            base[17]= VV[303];
6553            vs_top=(vs_base=base+3)+15;
6554            LlistA();
6555            vs_top=sup;
6556            base[2]= vs_base[0];
6557            base[3]= VV[54];
6558            base[4]= VV[304];
6559            base[5]= VV[55];
6560            base[6]= VV[305];
6561            base[7]= VV[60];
6562            base[8]= VV[306];
6563            base[9]= VV[59];
6564            base[10]= Cnil;
6565            base[11]= VV[57];
6566            if(((V620))==Cnil){
6567            goto T2407;}
6568            base[12]= VV[307];
6569            goto T2405;
6570            goto T2407;
6571    T2407:;
6572            base[12]= Ct;
6573            goto T2405;
6574    T2405:;
6575            vs_top=(vs_base=base+1)+12;
6576            (void) (*Lnk397)();
6577            vs_top=sup;
6578            V621= vs_base[0];
6579            base[1]= VV[308];
6580            base[2]= VV[309];
6581            base[3]= (V621);
6582            base[4]= VV[229];
6583            base[5]= VV[310];
6584            base[6]= VV[230];
6585            base[7]= Cnil;
6586            base[8]= VV[228];
6587            base[9]= VV[311];
6588            vs_top=(vs_base=base+1)+9;
6589            (void) (*Lnk398)();
6590            vs_top=sup;
6591            base[1]= VV[312];
6592            base[2]= VV[309];
6593            base[3]= (V621);
6594            base[4]= VV[229];
6595            base[5]= VV[313];
6596            base[6]= VV[230];
6597            base[7]= Cnil;
6598            base[8]= VV[228];
6599            base[9]= VV[314];
6600            vs_top=(vs_base=base+1)+9;
6601            (void) (*Lnk398)();
6602            vs_top=sup;
6603            base[1]= VV[315];
6604            base[2]= VV[316];
6605            base[3]= (V621);
6606            base[4]= VV[229];
6607            base[5]= VV[317];
6608            base[6]= VV[230];
6609            base[7]= Cnil;
6610            base[8]= VV[228];
6611            base[9]= VV[318];
6612            vs_top=(vs_base=base+1)+9;
6613            (void) (*Lnk398)();
6614            vs_top=sup;
6615            base[1]= VV[319];
6616            base[2]= VV[316];
6617            base[3]= (V621);
6618            base[4]= VV[229];
6619            base[5]= VV[320];
6620            base[6]= VV[230];
6621            base[7]= Cnil;
6622            base[8]= VV[228];
6623            base[9]= VV[321];
6624            vs_top=(vs_base=base+1)+9;
6625            (void) (*Lnk398)();
6626            vs_top=sup;
6627            base[1]= VV[322];
6628            base[2]= VV[316];
6629            base[3]= (V621);
6630            base[4]= VV[229];
6631            base[5]= VV[323];
6632            base[6]= VV[230];
6633            base[7]= Cnil;
6634            base[8]= VV[228];
6635            base[9]= VV[324];
6636            vs_top=(vs_base=base+1)+9;
6637            (void) (*Lnk398)();
6638            vs_top=sup;
6639            base[1]= (V621);
6640            vs_top=(vs_base=base+1)+1;
6641            return;}
6642            }
6643    }
6644    /*      function definition for LOOP-STANDARD-EXPANSION */
6645    
6646    static void L103()
6647    {register object *base=vs_base;
6648            register object *sup=base+VM90; VC90
6649            vs_reserve(VM90);
6650            {register object V622;
6651            object V623;
6652            object V624;
6653            check_arg(3);
6654            V622=(base[0]);
6655            V623=(base[1]);
6656            V624=(base[2]);
6657            vs_top=sup;
6658            goto TTL;
6659    TTL:;
6660            if(((V622))==Cnil){
6661            goto T2460;}
6662            if(!(type_of(car((V622)))==t_symbol)){
6663            goto T2460;}
6664            base[3]= (V622);
6665            base[4]= (V623);
6666            base[5]= (V624);
6667            vs_top=(vs_base=base+3)+3;
6668            (void) (*Lnk399)();
6669            return;
6670            goto T2460;
6671    T2460:;
6672            {object V625;
6673            vs_base=vs_top;
6674            Lgensym();
6675            vs_top=sup;
6676            V625= vs_base[0];
6677            V626= make_cons(VV[14],(V622));
6678            base[3]= list(3,VV[124],Cnil,list(4,VV[73],(V625),/* INLINE-ARGS */V626,list(2,VV[82],(V625))));
6679            vs_top=(vs_base=base+3)+1;
6680            return;}
6681            }
6682    }
6683    /*      macro definition for LOOP       */
6684    
6685    static void L104()
6686    {register object *base=vs_base;
6687            register object *sup=base+VM91; VC91
6688            vs_reserve(VM91);
6689            check_arg(2);
6690            vs_top=sup;
6691            {object V627=base[0]->c.c_cdr;
6692            base[2]= V627;}
6693            base[3]= base[2];
6694            base[4]= base[1];
6695            base[5]= symbol_value(VV[325]);
6696            vs_top=(vs_base=base+3)+3;
6697            (void) (*Lnk400)();
6698            return;
6699    }
6700    /*      local function IN-GROUP-P       */
6701    
6702    static void LC96(base0)
6703    register object *base0;
6704    {       register object *base=vs_base;
6705            register object *sup=base+VM92; VC92
6706            vs_reserve(VM92);
6707            {object V628;
6708            object V629;
6709            check_arg(2);
6710            V628=(base[0]);
6711            V629=(base[1]);
6712            vs_top=sup;
6713            base[2]= (V628);
6714            base[3]= (V629);
6715            vs_top=(vs_base=base+2)+2;
6716            (void) (*Lnk353)();
6717            vs_top=sup;
6718            V630= vs_base[0];
6719            base[2]= car(V630);
6720            vs_top=(vs_base=base+2)+1;
6721            return;
6722            }
6723    }
6724    /*      local function IN-GROUP-P       */
6725    
6726    static void L96(base0)
6727    register object *base0;
6728    {       register object *base=vs_base;
6729            register object *sup=base+VM93; VC93
6730            vs_reserve(VM93);
6731            {object V631;
6732            object V632;
6733            check_arg(2);
6734            V631=(base[0]);
6735            V632=(base[1]);
6736            vs_top=sup;
6737            goto TTL;
6738    TTL:;
6739            base[2]= (V631);
6740            base[3]= (V632);
6741            vs_top=(vs_base=base+2)+2;
6742            (void) (*Lnk353)();
6743            vs_top=sup;
6744            V633= vs_base[0];
6745            base[2]= car(V633);
6746            vs_top=(vs_base=base+2)+1;
6747            return;
6748            }
6749    }
6750    /*      local function MAKE-ENDTEST     */
6751    
6752    static void L82(base0)
6753    register object *base0;
6754    {       register object *base=vs_base;
6755            register object *sup=base+VM94; VC94
6756            vs_reserve(VM94);
6757            {object V634;
6758            check_arg(1);
6759            V634=(base[0]);
6760            vs_top=sup;
6761            goto TTL;
6762    TTL:;
6763            if(((V634))!=Cnil){
6764            goto T2478;}
6765            base[1]= Cnil;
6766            vs_top=(vs_base=base+1)+1;
6767            return;
6768            goto T2478;
6769    T2478:;
6770            {register object x= Ct,V635= (V634);
6771            while(!endp(V635))
6772            if(eql(x,V635->c.c_car)){
6773            goto T2482;
6774            }else V635=V635->c.c_cdr;
6775            goto T2481;}
6776            goto T2482;
6777    T2482:;
6778            base[1]= VV[192];
6779            vs_top=(vs_base=base+1)+1;
6780            return;
6781            goto T2481;
6782    T2481:;
6783            V634= nreverse((V634));
6784            if((cdr((V634)))!=Cnil){
6785            goto T2485;}
6786            V636= car((V634));
6787            goto T2483;
6788            goto T2485;
6789    T2485:;
6790            V636= make_cons(VV[35],(V634));
6791            goto T2483;
6792    T2483:;
6793            base[1]= list(3,VV[8],V636,VV[193]);
6794            vs_top=(vs_base=base+1)+1;
6795            return;
6796            }
6797    }
6798    /*      local function GET-CLAUSE       */
6799    
6800    static void L66(base0)
6801    register object *base0;
6802    {       register object *base=vs_base;
6803            register object *sup=base+VM95; VC95
6804            vs_reserve(VM95);
6805            {object V637;
6806            check_arg(1);
6807            V637=(base[0]);
6808            vs_top=sup;
6809            goto TTL;
6810    TTL:;
6811            {register object V638;
6812            V638= Cnil;
6813            goto T2489;
6814    T2489:;
6815            {register object V639;
6816            register object V640;
6817            V639= car(symbol_value(VV[89]));
6818            bds_bind(VV[109],Cnil);
6819            V640= Cnil;
6820            if(type_of((V639))==t_symbol){
6821            goto T2495;}
6822            base[2]= VV[152];
6823            base[3]= (V639);
6824            base[4]= (V637);
6825            vs_top=(vs_base=base+2)+3;
6826            (void) (*Lnk347)();
6827            vs_top=sup;
6828            bds_unwind1;
6829            goto T2492;
6830            goto T2495;
6831    T2495:;
6832            setq(VV[88],symbol_value(VV[89]));
6833            vs_base=vs_top;
6834            (void) (*Lnk350)();
6835            vs_top=sup;
6836            base[2]= car(symbol_value(VV[89]));
6837            base[3]= VV[153];
6838            vs_top=(vs_base=base+2)+2;
6839            (void) (*Lnk357)();
6840            vs_top=sup;
6841            if((vs_base[0])==Cnil){
6842            goto T2503;}
6843            if(base0[3]!=Cnil){
6844            V641= base0[3];
6845            goto T2509;}
6846            vs_base=vs_top;
6847            (void) (*Lnk378)();
6848            vs_top=sup;
6849            base0[3]= vs_base[0];
6850            V641= base0[3];
6851            goto T2509;
6852    T2509:;
6853            setq(VV[89],make_cons(V641,cdr(symbol_value(VV[89]))));
6854            goto T2503;
6855    T2503:;
6856            base[2]= (V639);
6857            base[3]= structure_ref(symbol_value(VV[97]),VV[39],0);
6858            vs_top=(vs_base=base+2)+2;
6859            (void) (*Lnk351)();
6860            vs_top=sup;
6861            V640= vs_base[0];
6862            if(((V640))==Cnil){
6863            goto T2511;}
6864            base[3]= car((V640));
6865            vs_top=(vs_base=base+3)+1;
6866            Lsymbol_function();
6867            vs_top=sup;
6868            base[2]= vs_base[0];
6869            {object V642;
6870            V642= cdr((V640));
6871             vs_top=base+3;
6872             while(!endp(V642))
6873             {vs_push(car(V642));V642=cdr(V642);}
6874            vs_base=base+3;}
6875            super_funcall_no_event(base[2]);
6876            vs_top=sup;
6877            if(!(((VV[109]->s.s_dbind))==Cnil)){
6878            goto T2512;}
6879            goto T2511;
6880    T2511:;
6881            base[2]= VV[154];
6882            base[3]= (V639);
6883            base[4]= (V637);
6884            vs_top=(vs_base=base+2)+3;
6885            (void) (*Lnk347)();
6886            vs_top=sup;
6887            bds_unwind1;
6888            goto T2492;
6889            goto T2512;
6890    T2512:;
6891            base[2]= (VV[109]->s.s_dbind);
6892            base[3]= (V638);
6893            vs_top=(vs_base=base+2)+2;
6894            Lreconc();
6895            vs_top=sup;
6896            V638= vs_base[0];
6897            bds_unwind1;}
6898            goto T2492;
6899    T2492:;
6900            base[1]= car(symbol_value(VV[89]));
6901            base[2]= VV[155];
6902            vs_top=(vs_base=base+1)+2;
6903            (void) (*Lnk357)();
6904            vs_top=sup;
6905            if((vs_base[0])==Cnil){
6906            goto T2531;}
6907            vs_base=vs_top;
6908            (void) (*Lnk350)();
6909            vs_top=sup;
6910            goto T2529;
6911            goto T2531;
6912    T2531:;
6913            if((cdr((V638)))==Cnil){
6914            goto T2536;}
6915            V643= nreverse((V638));
6916            base[1]= make_cons(VV[14],/* INLINE-ARGS */V643);
6917            vs_top=(vs_base=base+1)+1;
6918            return;
6919            goto T2536;
6920    T2536:;
6921            base[1]= car((V638));
6922            vs_top=(vs_base=base+1)+1;
6923            return;
6924            goto T2529;
6925    T2529:;
6926            goto T2489;}
6927            }
6928    }
6929    /*      local function REPLICATE        */
6930    
6931    static void L59(base0)
6932    register object *base0;
6933    {       register object *base=vs_base;
6934            register object *sup=base+VM96; VC96
6935            vs_reserve(VM96);
6936            {object V644;
6937            object V645;
6938            check_arg(2);
6939            V644=(base[0]);
6940            V645=(base[1]);
6941            vs_top=sup;
6942            goto TTL;
6943    TTL:;
6944            if(!(type_of((V645))!=t_cons)){
6945            goto T2541;}
6946            base[2]= (V644);
6947            vs_top=(vs_base=base+2)+1;
6948            return;
6949            goto T2541;
6950    T2541:;
6951            base[2]= (V644);
6952            base[3]= car((V645));
6953            vs_top=(vs_base=base+2)+2;
6954            L59(base0);
6955            vs_top=sup;
6956            V646= vs_base[0];
6957            base[2]= (V644);
6958            base[3]= cdr((V645));
6959            vs_top=(vs_base=base+2)+2;
6960            L59(base0);
6961            vs_top=sup;
6962            V647= vs_base[0];
6963            base[2]= make_cons(V646,V647);
6964            vs_top=(vs_base=base+2)+1;
6965            return;
6966            }
6967    }
6968    /*      local function TRANSLATE        */
6969    
6970    static void L58(base0)
6971    register object *base0;
6972    {       register object *base=vs_base;
6973            register object *sup=base+VM97; VC97
6974            vs_reserve(VM97);
6975            {register object V648;
6976            register object V649;
6977            check_arg(2);
6978            V648=(base[0]);
6979            V649=(base[1]);
6980            vs_top=sup;
6981            goto TTL;
6982    TTL:;
6983            if(((V648))!=Cnil){
6984            goto T2550;}
6985            base[2]= Cnil;
6986            vs_top=(vs_base=base+2)+1;
6987            return;
6988            goto T2550;
6989    T2550:;
6990            if(!(type_of((V648))!=t_cons)){
6991            goto T2553;}{object V650;
6992            base[3]= (V648);
6993            base[4]= structure_ref(symbol_value(VV[97]),VV[39],4);
6994            vs_top=(vs_base=base+3)+2;
6995            Lgethash();
6996            vs_top=sup;
6997            V650= vs_base[0];
6998            if(V650==Cnil)goto T2556;
6999            base[2]= V650;
7000            goto T2555;
7001            goto T2556;
7002    T2556:;}{object V651;
7003            base[3]= symbol_name((V648));
7004            base[4]= structure_ref(symbol_value(VV[97]),VV[39],5);
7005            vs_top=(vs_base=base+3)+2;
7006            Lgethash();
7007            vs_top=sup;
7008            V651= vs_base[0];
7009            if(V651==Cnil)goto T2560;
7010            base[2]= V651;
7011            goto T2555;
7012            goto T2560;
7013    T2560:;}
7014            base[3]= VV[140];
7015            base[4]= base0[1];
7016            base[5]= (V648);
7017            vs_top=(vs_base=base+3)+3;
7018            (void) (*Lnk347)();
7019            vs_top=sup;
7020            base[2]= vs_base[0];
7021            goto T2555;
7022    T2555:;
7023            base[3]= (V649);
7024            vs_top=(vs_base=base+2)+2;
7025            L59(base0);
7026            return;
7027            goto T2553;
7028    T2553:;
7029            if(!(type_of((V649))!=t_cons)){
7030            goto T2569;}
7031            base[2]= VV[141];
7032            base[3]= base0[1];
7033            base[4]= base0[0];
7034            vs_top=(vs_base=base+2)+3;
7035            (void) (*Lnk347)();
7036            return;
7037            goto T2569;
7038    T2569:;
7039            base[2]= car((V648));
7040            base[3]= car((V649));
7041            vs_top=(vs_base=base+2)+2;
7042            L58(base0);
7043            vs_top=sup;
7044            V652= vs_base[0];
7045            base[2]= cdr((V648));
7046            base[3]= cdr((V649));
7047            vs_top=(vs_base=base+2)+2;
7048            L58(base0);
7049            vs_top=sup;
7050            V653= vs_base[0];
7051            base[2]= make_cons(V652,V653);
7052            vs_top=(vs_base=base+2)+1;
7053            return;
7054            }
7055    }
7056    /*      local function LIST-SIZE        */
7057    
7058    static void L40(base0)
7059    register object *base0;
7060    {       register object *base=vs_base;
7061            register object *sup=base+VM98; VC98
7062            vs_reserve(VM98);
7063            {object V654;
7064            check_arg(1);
7065            V654=(base[0]);
7066            vs_top=sup;
7067            goto TTL;
7068    TTL:;
7069            {long V655;
7070            V655= 0;
7071            {register object V656;
7072            object V657;
7073            V656= (V654);
7074            V657= car((V656));
7075            goto T2584;
7076    T2584:;
7077            if(!(endp_prop((V656)))){
7078            goto T2585;}
7079            base[2]= make_fixnum(V655);
7080            vs_top=(vs_base=base+2)+1;
7081            return;
7082            goto T2585;
7083    T2585:;
7084            V658 = make_fixnum(V655);
7085            base[2]= (V657);
7086            base[3]= base0[1];
7087            vs_top=(vs_base=base+2)+2;
7088            (void) (*Lnk342)();
7089            vs_top=sup;
7090            V659= vs_base[0];
7091            V655= fix(number_plus(V658,V659));
7092            V656= cdr((V656));
7093            V657= car((V656));
7094            goto T2584;}}
7095            }
7096    }
7097    /*      local function MAKEBODY */
7098    
7099    static void L35(base0)
7100    register object *base0;
7101    {       register object *base=vs_base;
7102            register object *sup=base+VM99; VC99
7103            vs_reserve(VM99);
7104            check_arg(0);
7105            vs_top=sup;
7106            goto TTL;
7107    TTL:;
7108            {object V660;
7109            V662= nreverse(base0[7]);
7110            base[0]= append(base0[2],/* INLINE-ARGS */V662);
7111            vs_top=(vs_base=base+0)+1;
7112            L33(base0);
7113            vs_top=sup;
7114            V661= vs_base[0];
7115            base[1]= base0[8];
7116            base[2]= VV[75];
7117            vs_top=(vs_base=base+1)+2;
7118            Lreconc();
7119            vs_top=sup;
7120            V664= vs_base[0];
7121            base[0]= append(base0[4],V664);
7122            vs_top=(vs_base=base+0)+1;
7123            L33(base0);
7124            vs_top=sup;
7125            V663= vs_base[0];
7126            base[0]= base0[6];
7127            vs_top=(vs_base=base+0)+1;
7128            L33(base0);
7129            vs_top=sup;
7130            V665= vs_base[0];
7131            V666= make_cons(VV[76],V665);
7132            V667= append(V663,/* INLINE-ARGS */V666);
7133            V668= make_cons(VV[74],/* INLINE-ARGS */V667);
7134            V669= append(V661,/* INLINE-ARGS */V668);
7135            V660= make_cons(VV[73],/* INLINE-ARGS */V669);
7136            if((base0[9])==Cnil){
7137            goto T2610;}
7138            V670= list(2,base0[9],Cnil);
7139            base[0]= list(3,VV[29],make_cons(/* INLINE-ARGS */V670,Cnil),(V660));
7140            vs_top=(vs_base=base+0)+1;
7141            return;
7142            goto T2610;
7143    T2610:;
7144            base[0]= (V660);
7145            vs_top=(vs_base=base+0)+1;
7146            return;}
7147    }
7148    /*      local function PIFY     */
7149    
7150    static void L34(base0)
7151    register object *base0;
7152    {       register object *base=vs_base;
7153            register object *sup=base+VM100; VC100
7154            vs_reserve(VM100);
7155            {object V671;
7156            check_arg(1);
7157            V671=(base[0]);
7158            vs_top=sup;
7159            goto TTL;
7160    TTL:;
7161            if((cdr((V671)))!=Cnil){
7162            goto T2613;}
7163            base[1]= car((V671));
7164            vs_top=(vs_base=base+1)+1;
7165            return;
7166            goto T2613;
7167    T2613:;
7168            base[1]= make_cons(VV[14],(V671));
7169            vs_top=(vs_base=base+1)+1;
7170            return;
7171            }
7172    }
7173    /*      local function PSIMP    */
7174    
7175    static void L33(base0)
7176    register object *base0;
7177    {       register object *base=vs_base;
7178            register object *sup=base+VM101; VC101
7179            vs_reserve(VM101);
7180            {object V672;
7181            check_arg(1);
7182            V672=(base[0]);
7183            vs_top=sup;
7184            goto TTL;
7185    TTL:;
7186            {register object V673;
7187            V673= Cnil;
7188            {register object V674;
7189            register object V675;
7190            V674= (V672);
7191            V675= car((V674));
7192            goto T2619;
7193    T2619:;
7194            if(!(endp_prop((V674)))){
7195            goto T2620;}
7196            goto T2615;
7197            goto T2620;
7198    T2620:;
7199            if(((V675))==Cnil){
7200            goto T2624;}
7201            {register object V676;
7202            V676= (V675);
7203            V673= make_cons((V676),(V673));}
7204            if(!(type_of((V675))==t_cons)){
7205            goto T2624;}
7206            {register object x= car((V675)),V677= VV[72];
7207            while(!endp(V677))
7208            if(eql(x,V677->c.c_car)){
7209            goto T2633;
7210            }else V677=V677->c.c_cdr;
7211            goto T2624;}
7212            goto T2633;
7213    T2633:;
7214            goto T2615;
7215            goto T2624;
7216    T2624:;
7217            V674= cdr((V674));
7218            V675= car((V674));
7219            goto T2619;}
7220            goto T2615;
7221    T2615:;
7222            base[1]= nreverse((V673));
7223            vs_top=(vs_base=base+1)+1;
7224            return;}
7225            }
7226    }
7227    /*      local function FIND-NON-NULL    */
7228    
7229    static void L27(base0)
7230    register object *base0;
7231    {       register object *base=vs_base;
7232            register object *sup=base+VM102; VC102
7233            vs_reserve(VM102);
7234            {object V678;
7235            check_arg(1);
7236            V678=(base[0]);
7237            vs_top=sup;
7238            goto TTL;
7239    TTL:;
7240            {register object V679;
7241            V679= (V678);
7242            goto T2640;
7243    T2640:;
7244            if(type_of((V679))==t_cons){
7245            goto T2641;}
7246            base[1]= (V679);
7247            vs_top=(vs_base=base+1)+1;
7248            return;
7249            goto T2641;
7250    T2641:;
7251            {register object V680;
7252            V680= car((V679));
7253            V679= cdr((V679));
7254            base[1]= (V680);}
7255            vs_top=(vs_base=base+1)+1;
7256            L27(base0);
7257            vs_top=sup;
7258            if((vs_base[0])==Cnil){
7259            goto T2645;}
7260            base[1]= Ct;
7261            vs_top=(vs_base=base+1)+1;
7262            return;
7263            goto T2645;
7264    T2645:;
7265            goto T2640;}
7266            }
7267    }
7268    /*      local function LOOP-DESETQ-INTERNAL     */
7269    
7270    static void L28(base0)
7271    register object *base0;
7272    {       register object *base=vs_base;
7273            register object *sup=base+VM103; VC103
7274            vs_reserve(VM103);
7275            {register object V681;
7276            register object V682;
7277            object V683;
7278            if(vs_top-vs_base<2) too_few_arguments();
7279            if(vs_top-vs_base>3) too_many_arguments();
7280            V681=(base[0]);
7281            V682=(base[1]);
7282            vs_base=vs_base+2;
7283            if(vs_base>=vs_top){vs_top=sup;goto T2654;}
7284            V683=(base[2]);
7285            vs_top=sup;
7286            goto T2655;
7287            goto T2654;
7288    T2654:;
7289            V683= Cnil;
7290            goto T2655;
7291    T2655:;
7292            {register object V684;
7293            V684= (V681);
7294            if(!(((V684))==Cnil)){
7295            goto T2658;}
7296            if(!(type_of((V682))==t_cons)){
7297            goto T2661;}
7298            if(!((car((V682)))==(VV[62]))){
7299            goto T2664;}
7300            {object V685;
7301            object V686= cdr((V682));
7302            if(endp(V686)){
7303            base[4]= Cnil;
7304            vs_top=(vs_base=base+4)+1;
7305            return;}
7306            base[3]=V685=MMcons(Cnil,Cnil);
7307            goto T2666;
7308    T2666:;
7309            {register object V687;
7310            V687= (V686->c.c_car);
7311            if(type_of((V687))==t_cons){
7312            goto T2668;}
7313            (V685->c.c_cdr)= Cnil;
7314            goto T2667;
7315            goto T2668;
7316    T2668:;
7317            if(!((((car((V687)))==(VV[65])?Ct:Cnil))==Cnil)){
7318            goto T2672;}
7319            goto T2670;
7320            goto T2672;
7321    T2672:;
7322            if(!(((type_of(cadr((V687)))==t_symbol?Ct:Cnil))==Cnil)){
7323            goto T2674;}
7324            goto T2670;
7325            goto T2674;
7326    T2674:;
7327            base[4]= (V687);
7328            base[5]= base0[1];
7329            vs_top=(vs_base=base+4)+2;
7330            Lmacroexpand();
7331            vs_top=sup;
7332            V687= vs_base[0];
7333            if(((type_of((V687))==t_symbol?Ct:Cnil))==Cnil){
7334            goto T2670;}
7335            (V685->c.c_cdr)= Cnil;
7336            goto T2667;
7337            goto T2670;
7338    T2670:;
7339            (V685->c.c_cdr)= make_cons((V687),Cnil);}
7340            goto T2667;
7341    T2667:;
7342            {object cdr_V685=MMcdr(V685);while(!endp(cdr_V685)) {cdr_V685=MMcdr(cdr_V685);V685=MMcdr(V685);}}
7343            V686=MMcdr(V686);
7344            if(endp(V686)){
7345            base[3]=base[3]->c.c_cdr;
7346            vs_top=(vs_base=base+3)+1;
7347            return;}
7348            goto T2666;}
7349            goto T2664;
7350    T2664:;
7351            base[3]= make_cons((V682),Cnil);
7352            vs_top=(vs_base=base+3)+1;
7353            return;
7354            goto T2661;
7355    T2661:;
7356            base[3]= Cnil;
7357            vs_top=(vs_base=base+3)+1;
7358            return;
7359            goto T2658;
7360    T2658:;
7361            if(!(type_of((V684))==t_cons)){
7362            goto T2680;}
7363            {object V688;
7364            object V689;
7365            object V690;
7366            object V691;
7367            V688= car((V681));
7368            V689= cdr((V681));
7369            base[7]= (V688);
7370            vs_top=(vs_base=base+7)+1;
7371            L27(base0);
7372            vs_top=sup;
7373            V690= vs_base[0];
7374            base[7]= (V689);
7375            vs_top=(vs_base=base+7)+1;
7376            L27(base0);
7377            vs_top=sup;
7378            V691= vs_base[0];
7379            if(((V690))!=Cnil){
7380            goto T2688;}
7381            if(((V691))==Cnil){
7382            goto T2689;}
7383            goto T2688;
7384    T2688:;
7385            if(((V691))==Cnil){
7386            goto T2694;}
7387            {register object V693;
7388            object V694;
7389            if((V683)!=Cnil){
7390            V693= (V683);
7391            goto T2696;}
7392            V693= symbol_value(VV[66]);
7393            goto T2696;
7394    T2696:;
7395            base[9]= (V688);
7396            base[10]= list(2,VV[65],(V693));
7397            vs_top=(vs_base=base+9)+2;
7398            L28(base0);
7399            vs_top=sup;
7400            V695= vs_base[0];
7401            V696= list(3,VV[11],(V693),list(2,VV[10],(V693)));
7402            base[9]= (V689);
7403            base[10]= (V693);
7404            base[11]= (V693);
7405            vs_top=(vs_base=base+9)+3;
7406            L28(base0);
7407            vs_top=sup;
7408            V697= vs_base[0];
7409            V698= make_cons(/* INLINE-ARGS */V696,V697);
7410            V694= append(V695,/* INLINE-ARGS */V698);
7411            if((V683)==Cnil){
7412            goto T2706;}
7413            if(((V693))==((V682))){
7414            goto T2710;}
7415            V700= list(3,VV[11],(V693),(V682));
7416            V699= make_cons(/* INLINE-ARGS */V700,Cnil);
7417            goto T2708;
7418            goto T2710;
7419    T2710:;
7420            V699= Cnil;
7421            goto T2708;
7422    T2708:;
7423            base[9]= append(V699,(V694));
7424            vs_top=(vs_base=base+9)+1;
7425            return;
7426            goto T2706;
7427    T2706:;
7428            V701= list(2,(V693),(V682));
7429            V702= listA(3,VV[29],make_cons(/* INLINE-ARGS */V701,Cnil),(V694));
7430            base[9]= make_cons(/* INLINE-ARGS */V702,Cnil);
7431            vs_top=(vs_base=base+9)+1;
7432            return;}
7433            goto T2694;
7434    T2694:;
7435            base[7]= (V688);
7436            base[8]= list(2,VV[65],(V682));
7437            base[9]= (V683);
7438            vs_top=(vs_base=base+7)+3;
7439            L28(base0);
7440            return;
7441            goto T2689;
7442    T2689:;
7443            base[7]= Cnil;
7444            vs_top=(vs_base=base+7)+1;
7445            return;}
7446            goto T2680;
7447    T2680:;
7448            if(((V681))==((V682))){
7449            goto T2716;}
7450            V703= list(3,VV[11],(V681),(V682));
7451            base[3]= make_cons(/* INLINE-ARGS */V703,Cnil);
7452            vs_top=(vs_base=base+3)+1;
7453            return;
7454            goto T2716;
7455    T2716:;
7456            base[3]= Cnil;
7457            vs_top=(vs_base=base+3)+1;
7458            return;}
7459            }
7460    }
7461    /*      local function MAKETABLE        */
7462    
7463    static void L23(base0)
7464    register object *base0;
7465    {       register object *base=vs_base;
7466            register object *sup=base+VM104; VC104
7467            vs_reserve(VM104);
7468            {object V704;
7469            check_arg(1);
7470            V704=(base[0]);
7471            vs_top=sup;
7472            goto TTL;
7473    TTL:;
7474            {object V705;
7475            object V706;
7476            V705= make_fixnum((long)length((V704)));
7477            base[3]= VV[61];
7478            if(!(number_compare((V705),small_fixnum(10))<0)){
7479            goto T2723;}
7480            base[4]= small_fixnum(10);
7481            goto T2721;
7482            goto T2723;
7483    T2723:;
7484            base[4]= (V705);
7485            goto T2721;
7486    T2721:;
7487            base[5]= VV[20];
7488            base[6]= symbol_function(VV[401]);
7489            vs_top=(vs_base=base+3)+4;
7490            Lmake_hash_table();
7491            vs_top=sup;
7492            V706= vs_base[0];
7493            {register object V707;
7494            register object V708;
7495            V707= (V704);
7496            V708= car((V707));
7497            goto T2731;
7498    T2731:;
7499            if(!(endp_prop((V707)))){
7500            goto T2732;}
7501            goto T2727;
7502            goto T2732;
7503    T2732:;
7504            {object V709;
7505            object V711;
7506            V709= symbol_name(car((V708)));
7507            V711= cadr((V708));
7508            base[6]= (V709);
7509            base[7]= V706;
7510            base[8]= (V711);
7511            vs_top=(vs_base=base+6)+3;
7512            siLhash_set();
7513            vs_top=sup;}
7514            V707= cdr((V707));
7515            V708= car((V707));
7516            goto T2731;}
7517            goto T2727;
7518    T2727:;
7519            base[3]= (V706);
7520            vs_top=(vs_base=base+3)+1;
7521            return;}
7522            }
7523    }
7524    /*      local function CDR-WRAP */
7525    
7526    static void L8(base0)
7527    register object *base0;
7528    {       register object *base=vs_base;
7529            register object *sup=base+VM105; VC105
7530            vs_reserve(VM105);
7531            {register object V712;
7532            register long V713;
7533            check_arg(2);
7534            V712=(base[0]);
7535            V713=fix(base[1]);
7536            vs_top=sup;
7537            goto TTL;
7538    TTL:;
7539            goto T2748;
7540    T2748:;
7541            if(!((V713)<=(4))){
7542            goto T2749;}switch(V713){
7543            case 1:
7544            goto T2755;
7545    T2755:;
7546            V714= VV[10];
7547            goto T2753;
7548            case 2:
7549            goto T2756;
7550    T2756:;
7551            V714= VV[15];
7552            goto T2753;
7553            case 3:
7554            goto T2757;
7555    T2757:;
7556            V714= VV[16];
7557            goto T2753;
7558            case 4:
7559            goto T2758;
7560    T2758:;
7561            V714= VV[17];
7562            goto T2753;
7563            default:
7564            goto T2759;
7565    T2759:;
7566            V714= Cnil;
7567            goto T2753;}
7568            V714= Cnil;
7569            goto T2753;
7570    T2753:;
7571            V712= list(2,V714,(V712));
7572            base[2]= (V712);
7573            vs_top=(vs_base=base+2)+1;
7574            return;
7575            goto T2749;
7576    T2749:;
7577            V712= list(2,VV[17],(V712));
7578            V713= (long)(V713)-(4);
7579            goto T2748;
7580            }
7581    }
7582    static void LnkT400(){ call_or_link(VV[400],(void **)(void *)&Lnk400);} /* LOOP-STANDARD-EXPANSION */
7583    static void LnkT399(){ call_or_link(VV[399],(void **)(void *)&Lnk399);} /* LOOP-TRANSLATE */
7584    static void LnkT398(){ call_or_link(VV[398],(void **)(void *)&Lnk398);} /* ADD-LOOP-PATH */
7585    static void LnkT397(){ call_or_link(VV[397],(void **)(void *)&Lnk397);} /* MAKE-STANDARD-LOOP-UNIVERSE */
7586    static void LnkT394(){ call_or_link(VV[394],(void **)(void *)&Lnk394);} /* NAMED-VARIABLE */
7587    static void LnkT389(){ call_or_link(VV[389],(void **)(void *)&Lnk389);} /* LOOP-SEQUENCER */
7588    static object  LnkTLI386(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[386],(void **)(void *)&LnkLI386,first,ap);va_end(ap);return V1;} /* DELETE */
7589    static void LnkT385(){ call_or_link(VV[385],(void **)(void *)&Lnk385);} /* LOOP-TASSOC */
7590    static void LnkT384(){ call_or_link(VV[384],(void **)(void *)&Lnk384);} /* LOOP-COLLECT-PREPOSITIONAL-PHRASES */
7591    static void LnkT383(){ call_or_link(VV[383],(void **)(void *)&Lnk383);} /* MAKE-LOOP-PATH */
7592    static void LnkT382(){ call_or_link(VV[382],(void **)(void *)&Lnk382);} /* STRUCTURE-SUBTYPE-P */
7593    static void LnkT381(){ call_or_link(VV[381],(void **)(void *)&Lnk381);} /* LOOP-LIST-STEP */
7594    static void LnkT380(){ call_or_link(VV[380],(void **)(void *)&Lnk380);} /* LOOP-MAKE-ITERATION-VARIABLE */
7595    static void LnkT379(){ call_or_link(VV[379],(void **)(void *)&Lnk379);} /* LOOP-CONSTANT-FOLD-IF-POSSIBLE */
7596    static void LnkT378(){ call_or_link(VV[378],(void **)(void *)&Lnk378);} /* LOOP-WHEN-IT-VARIABLE */
7597    static void LnkT377(){ call_or_link(VV[377],(void **)(void *)&Lnk377);} /* LOOP-NOTE-MINIMAX-OPERATION */
7598    static void LnkT376(){ call_or_link(VV[376],(void **)(void *)&Lnk376);} /* MAKE-LOOP-MINIMAX */
7599    static void LnkT375(){ call_or_link(VV[375],(void **)(void *)&Lnk375);} /* LOOP-CHECK-DATA-TYPE */
7600    static void LnkT372(){ call_or_link(VV[372],(void **)(void *)&Lnk372);} /* LOOP-EMIT-FINAL-VALUE */
7601    static void LnkT371(){ call_or_link(VV[371],(void **)(void *)&Lnk371);} /* LOOP-GET-COLLECTION-INFO */
7602    static void LnkT370(){ call_or_link(VV[370],(void **)(void *)&Lnk370);} /* MAKE-LOOP-COLLECTOR */
7603    static object  LnkTLI368(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[368],(void **)(void *)&LnkLI368,first,ap);va_end(ap);return V1;} /* FIND */
7604    static void LnkT367(){ call_or_link(VV[367],(void **)(void *)&Lnk367);} /* LOOP-OPTIONAL-TYPE */
7605    static void LnkT364(){ call_or_link(VV[364],(void **)(void *)&Lnk364);} /* LOOP-EMIT-BODY */
7606    static void LnkT363(){ call_or_link(VV[363],(void **)(void *)&Lnk363);} /* LOOP-GET-PROGN */
7607    static void LnkT362(){ call_or_link(VV[362],(void **)(void *)&Lnk362);} /* LOOP-DISALLOW-CONDITIONAL */
7608    static void LnkT361(){ call_or_link(VV[361],(void **)(void *)&Lnk361);} /* LOOP-GET-FORM */
7609    static void LnkT360(){ call_or_link(VV[360],(void **)(void *)&Lnk360);} /* LOOP-CONSTANTP */
7610    static void LnkT359(){ call_or_link(VV[359],(void **)(void *)&Lnk359);} /* LOOP-MAKE-VARIABLE */
7611    static void LnkT358(){ call_or_link(VV[358],(void **)(void *)&Lnk358);} /* LOOP-DECLARE-VARIABLE */
7612    static void LnkT357(){ call_or_link(VV[357],(void **)(void *)&Lnk357);} /* LOOP-TEQUAL */
7613    static object  LnkTLI356(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_proc_new(VV[356],(void **)(void *)&LnkLI356,2,first,ap);va_end(ap);return V1;} /* COERCE */
7614    static void LnkT355(){ call_or_link(VV[355],(void **)(void *)&Lnk355);} /* LOOP-CONSTRUCT-RETURN */
7615    static void LnkT354(){ call_or_link(VV[354],(void **)(void *)&Lnk354);} /* LOOP-PSEUDO-BODY */
7616    static void LnkT353(){ call_or_link(VV[353],(void **)(void *)&Lnk353);} /* LOOP-TMEMBER */
7617    static void LnkT352(){ call_or_link(VV[352],(void **)(void *)&Lnk352);} /* LOOP-HACK-ITERATION */
7618    static void LnkT351(){ call_or_link(VV[351],(void **)(void *)&Lnk351);} /* LOOP-LOOKUP-KEYWORD */
7619    static void LnkT350(){ call_or_link(VV[350],(void **)(void *)&Lnk350);} /* LOOP-POP-SOURCE */
7620    static void LnkT349(){ call_or_link(VV[349],(void **)(void *)&Lnk349);} /* LOOP-BIND-BLOCK */
7621    static void LnkT348(){ call_or_link(VV[348],(void **)(void *)&Lnk348);} /* LOOP-ITERATION-DRIVER */
7622    static void LnkT347(){ call_or_link(VV[347],(void **)(void *)&Lnk347);} /* LOOP-ERROR */
7623    static void LnkT326(){ call_or_link(VV[326],(void **)(void *)&Lnk326);} /* SUBTYPEP */
7624    static object  LnkTLI346(object first,...){object V1;va_list ap;va_start(ap,first);V1=call_vproc_new(VV[346],(void **)(void *)&LnkLI346,first,ap);va_end(ap);return V1;} /* WARN */
7625    static void LnkT345(){ call_or_link(VV[345],(void **)(void *)&Lnk345);} /* SPECIFIC-ERROR */
7626    static void LnkT344(){ call_or_link(VV[344],(void **)(void *)&Lnk344);} /* LOOP-CONTEXT */
7627    static void LnkT343(){ call_or_link(VV[343],(void **)(void *)&Lnk343);} /* SPECIAL-OPERATOR-P */
7628    static void LnkT342(){ call_or_link(VV[342],(void **)(void *)&Lnk342);} /* ESTIMATE-CODE-SIZE-1 */
7629    static void LnkT341(){ call_or_link(VV[341],(void **)(void *)&Lnk341);} /* DESTRUCTURING-SIZE */
7630    static void LnkT77(){ call_or_link(VV[77],(void **)(void *)&Lnk77);} /* ESTIMATE-CODE-SIZE */
7631    static void LnkT340(){ call_or_link(VV[340],(void **)(void *)&Lnk340);} /* LOOP-CODE-DUPLICATION-THRESHOLD */
7632    static void LnkT339(){ call_or_link(VV[339],(void **)(void *)&Lnk339);} /* LOOP-OPTIMIZATION-QUANTITIES */
7633    static void LnkT338(){ call_or_link(VV[338],(void **)(void *)&Lnk338);} /* LOOP-WARN */
7634    static void LnkT337(){ call_or_link(VV[337],(void **)(void *)&Lnk337);} /* LOOP-MAKE-DESETQ */
7635    static void LnkT336(){ call_or_link(VV[336],(void **)(void *)&Lnk336);} /* LOOP-MAKE-PSETQ */
7636    static void LnkT335(){ call_or_link(VV[335],(void **)(void *)&Lnk335);} /* MAKE-LOOP-UNIVERSE */
7637    static void LnkT333(){ call_or_link(VV[333],(void **)(void *)&Lnk333);} /* TYPEP */
7638    static void LnkT331(){ call_or_link(VV[331],(void **)(void *)&Lnk331);} /* HIDE-VARIABLE-REFERENCE */
7639    static void LnkT329(){ call_or_link(VV[329],(void **)(void *)&Lnk329);} /* LOOP-TYPED-INIT */
7640    static void LnkT328(){ call_or_link(VV[328],(void **)(void *)&Lnk328);} /* MAKE-LOOP-MINIMAX-INTERNAL */
7641    static void LnkT327(){ call_or_link(VV[327],(void **)(void *)&Lnk327);} /* LOOP-GENTEMP */
7642    
7643    #ifdef SYSTEM_SPECIAL_INIT
7644    SYSTEM_SPECIAL_INIT
7645    #endif
7646    

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26