LABEL(paren_docol) /* (docol) ( -- R:a_retaddr ) */
/* run-time routine for colon definitions */
NAME("(docol)")
{
DEF_CA
Cell * a_retaddr;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
rp += -1;
{
#line 152 "./prim"
a_retaddr = (Cell *)IP;
SET_IP((Xt *)PFA(CFA));
#line 19 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_retaddr,rpTOS);
LABEL2(paren_docol)
NEXT_P2;
}

LABEL(paren_docon) /* (docon) ( -- w ) */
/* run-time routine for constants */
NAME("(docon)")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 157 "./prim"
w = *(Cell *)PFA(CFA);
#line 51 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(paren_docon)
NEXT_P2;
}

LABEL(paren_dovar) /* (dovar) ( -- a_body ) */
/* run-time routine for variables and CREATEd words */
NAME("(dovar)")
{
DEF_CA
Cell * a_body;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 161 "./prim"
a_body = PFA(CFA);
#line 82 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_body=", vm_out); printarg_a_(a_body);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_body,spTOS);
LABEL2(paren_dovar)
NEXT_P2;
}

LABEL(paren_douser) /* (douser) ( -- a_user ) */
/* run-time routine for constants */
NAME("(douser)")
{
DEF_CA
Cell * a_user;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 165 "./prim"
a_user = (Cell *)(up+*(Cell *)PFA(CFA));
#line 113 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_user=", vm_out); printarg_a_(a_user);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_user,spTOS);
LABEL2(paren_douser)
NEXT_P2;
}

LABEL(paren_dodefer) /* (dodefer) ( -- ) */
/* run-time routine for deferred words */
NAME("(dodefer)")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 169 "./prim"
ip=IP; /* undo any ip updating that may have been performed by NEXT_P0 */
SUPER_END; /* !! probably unnecessary and may lead to measurement errors */
EXEC(*(Xt *)PFA(CFA));
#line 143 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(paren_dodefer)
NEXT_P2;
}

LABEL(paren_field) /* (dofield) ( n1 -- n2 ) */
/* run-time routine for fields */
NAME("(dofield)")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 175 "./prim"
n2 = n1 + *(Cell *)PFA(CFA);
#line 173 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(paren_field)
NEXT_P2;
}

LABEL(paren_dodoes) /* (dodoes) ( -- a_body R:a_retaddr ) */
/* run-time routine for @code{does>}-defined words */
NAME("(dodoes)")
{
DEF_CA
Cell * a_body;
Cell * a_retaddr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
IF_rpTOS(rp[0] = rpTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
rp += -1;
{
#line 179 "./prim"
a_retaddr = (Cell *)IP;
a_body = PFA(CFA);
SET_IP(DOES_CODE1(CFA));
#line 209 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_body=", vm_out); printarg_a_(a_body);
fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_body,spTOS);
vm_a_2Cell(a_retaddr,rpTOS);
LABEL2(paren_dodoes)
NEXT_P2;
}

LABEL(paren_does_handler) /* (does-handler) ( -- ) */
/* just a slot to have an encoding for the DOESJUMP, 
which is no longer used anyway (!! eliminate this) */
NAME("(does-handler)")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 186 "./prim"
#line 240 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(paren_does_handler)
NEXT_P2;
}

GROUPADD(8)
GROUP( control, 8)
LABEL(noop) /* noop ( -- ) */
/*  */
NAME("noop")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 192 "./prim"
#line 267 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(noop)
NEXT_P2;
}

LABEL(call) /* call ( #a_callee -- R:a_retaddr ) */
/* Call callee (a variant of docol with inline argument). */
NAME("call")
{
DEF_CA
Cell * a_callee;
Cell * a_retaddr;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397760 ),a_callee);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_callee=", vm_out); printarg_a_(a_callee);
}
#endif
INC_IP(1);
rp += -1;
{
#line 197 "./prim"
#ifdef NO_IP
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_retaddr,rpTOS);

JUMP(a_callee);
#else
#ifdef DEBUG
    {
      CFA_TO_NAME((((Cell *)a_callee)-2));
      fprintf(stderr,"%08lx: call %08lx %.*s\n",(Cell)ip,(Cell)a_callee,
	      len,name);
    }
#endif
a_retaddr = (Cell *)IP;
SET_IP((Xt *)a_callee);
#endif
#line 323 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_retaddr,rpTOS);
LABEL2(call)
NEXT_P2;
}

LABEL(execute) /* execute ( xt -- ) */
/* Perform the semantics represented by the execution token, @i{xt}. */
NAME("execute")
{
DEF_CA
Xt xt;
NEXT_P0;
vm_Cell2xt(spTOS,xt);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" xt=", vm_out); printarg_xt(xt);
}
#endif
sp += 1;
{
#line 214 "./prim"
#ifndef NO_IP
ip=IP;
#endif
IF_spTOS(spTOS = sp[0]);
SUPER_END;
EXEC(xt);
#line 361 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(execute)
NEXT_P2;
}

LABEL(perform) /* perform ( a_addr -- ) */
/* @code{@@ execute}. */
NAME("perform")
{
DEF_CA
Cell * a_addr;
NEXT_P0;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 1;
{
#line 223 "./prim"
/* and pfe */
#ifndef NO_IP
ip=IP;
#endif
IF_spTOS(spTOS = sp[0]);
SUPER_END;
EXEC(*(Xt *)a_addr);
#line 398 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(perform)
NEXT_P2;
}

LABEL(semis) /* ;s ( R:w -- ) */
/* The primitive compiled by @code{EXIT}. */
NAME(";s")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(rpTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
rp += 1;
{
#line 235 "./prim"
#ifdef NO_IP
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);

goto *(void *)w;
#else
SET_IP((Xt *)w);
#endif
#line 443 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);
LABEL2(semis)
NEXT_P2;
}

LABEL(unloop) /* unloop ( R:w1 R:w2 -- ) */
/*  */
NAME("unloop")
{
DEF_CA
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2w(rp[1],w1);
vm_Cell2w(rpTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
rp += 2;
{
#line 243 "./prim"
/* !! alias for 2rdrop */
#line 478 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);
LABEL2(unloop)
NEXT_P2;
}

LABEL(lit_perform) /* lit-perform ( #a_addr -- ) */
/*  */
NAME("lit-perform")
{
DEF_CA
Cell * a_addr;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397761 ),a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(1);
{
#line 248 "./prim"
#ifndef NO_IP
ip=IP;
#endif
SUPER_END;
EXEC(*(Xt *)a_addr);
#line 513 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(lit_perform)
NEXT_P2;
}

LABEL(does_exec) /* does-exec ( #a_cfa -- R:nest a_pfa ) */
/*  */
NAME("does-exec")
{
DEF_CA
Cell * a_cfa;
Cell nest;
Cell * a_pfa;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397762 ),a_cfa);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_cfa=", vm_out); printarg_a_(a_cfa);
}
#endif
INC_IP(1);
sp += -1;
rp += -1;
{
#line 255 "./prim"
#ifdef NO_IP
/* compiled to LIT CALL by compile_prim */
assert(0);
#else
a_pfa = PFA(a_cfa);
nest = (Cell)IP;
IF_spTOS(spTOS = sp[0]);
#ifdef DEBUG
    {
      CFA_TO_NAME(a_cfa);
      fprintf(stderr,"%08lx: does %08lx %.*s\n",
	      (Cell)ip,(Cell)a_cfa,len,name);
    }
#endif
SET_IP(DOES_CODE1(a_cfa));
#endif
#line 564 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" nest=", vm_out); printarg_n(nest);
fputs(" a_pfa=", vm_out); printarg_a_(a_pfa);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nest,rpTOS);
vm_a_2Cell(a_pfa,spTOS);
LABEL2(does_exec)
NEXT_P2;
}

GROUPADD(8)
#ifdef HAS_GLOCALS
LABEL(branch_lp_plus_store_number) /* branch-lp+!# ( #a_target #nlocals -- ) */
/*  */
NAME("branch-lp+!#")
{
DEF_CA
Cell * a_target;
Cell nlocals;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397763 ),a_target);
vm_Cell2n(IMM_ARG(IP[1],305397764 ),nlocals);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlocals=", vm_out); printarg_n(nlocals);
}
#endif
INC_IP(2);
{
#line 275 "./prim"
/* this will probably not be used */
lp += nlocals;
#ifdef NO_IP
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;

JUMP(a_target);
#else
SET_IP((Xt *)a_target);
#endif
#line 619 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(branch_lp_plus_store_number)
NEXT_P2;
}

GROUPADD(1)
#endif
LABEL(branch) /* branch ( #a_target -- ) */
/*  */
NAME("branch")
{
DEF_CA
Cell * a_target;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397765 ),a_target);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
}
#endif
INC_IP(1);
{
#line 287 "./prim"
#ifdef NO_IP
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;

JUMP(a_target);
#else
SET_IP((Xt *)a_target);
#endif
#line 665 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(branch)
NEXT_P2;
}

LABEL(question_branch) /* ?branch ( #a_target f -- ) */
/*  */
NAME("?branch")
{
DEF_CA
Cell * a_target;
Bool f;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397766 ),a_target);
vm_Cell2f(spTOS,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(1);
sp += 1;
{
#line 338 "./prim"
	#ifdef NO_IP
#line 337
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);

#line 337
#endif
#line 337
if (f==0) {
#line 337
	#ifdef NO_IP
#line 337
JUMP(a_target);
#line 337
#else
#line 337
SET_IP((Xt *)a_target);
#line 337
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 337
#endif
#line 337
}
#line 337
SUPER_CONTINUE;
#line 337
#line 741 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(question_branch)
NEXT_P2;
}

GROUPADD(2)
#ifdef HAS_GLOCALS
LABEL(question_branch_lp_plus_store_number) /* ?branch-lp+!# ( #a_target #nlocals f -- ) */
/*  */
NAME("?branch-lp+!#")
{
DEF_CA
Cell * a_target;
Cell nlocals;
Bool f;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397767 ),a_target);
vm_Cell2n(IMM_ARG(IP[1],305397768 ),nlocals);
vm_Cell2f(spTOS,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlocals=", vm_out); printarg_n(nlocals);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(2);
sp += 1;
{
#line 338 "./prim"
	#ifdef NO_IP
#line 337
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);

#line 337
#endif
#line 337
if (f==0) {
#line 337
	lp += nlocals;
#line 337
#ifdef NO_IP
#line 337
JUMP(a_target);
#line 337
#else
#line 337
SET_IP((Xt *)a_target);
#line 337
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 337
#endif
#line 337
}
#line 337
SUPER_CONTINUE;
#line 337
#line 825 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(question_branch_lp_plus_store_number)
NEXT_P2;
}

GROUPADD(1)
#endif
GROUPADD(0)
#ifdef HAS_XCONDS
LABEL(question_dupe_question_branch) /* ?dup-?branch ( #a_target f -- f ) */
/* The run-time procedure compiled by @code{?DUP-IF}. */
NAME("?dup-?branch")
{
DEF_CA
Cell * a_target;
Bool f;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397769 ),a_target);
vm_Cell2f(spTOS,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(1);
{
#line 347 "./prim"
if (f==0) {
  sp++;
  IF_spTOS(spTOS = sp[0]);
#ifdef NO_IP
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;

JUMP(a_target);
#else
SET_IP((Xt *)a_target);
  SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
 NEXT_P2;
#endif
}
SUPER_CONTINUE;
#line 891 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(question_dupe_question_branch)
NEXT_P2;
}

LABEL(question_dupe_zero_equals_question_branch) /* ?dup-0=-?branch ( #a_target f -- ) */
/* The run-time procedure compiled by @code{?DUP-0=-IF}. */
NAME("?dup-0=-?branch")
{
DEF_CA
Cell * a_target;
Bool f;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397770 ),a_target);
vm_Cell2f(spTOS,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(1);
sp += 1;
{
#line 362 "./prim"
/* the approach taken here of declaring the word as having the stack
effect ( f -- ) and correcting for it in the branch-taken case costs a
few cycles in that case, but is easy to convert to a CONDBRANCH
invocation */
if (f!=0) {
  sp--;
#ifdef NO_IP
  JUMP(a_target);
#else
  SET_IP((Xt *)a_target);
  NEXT;
#endif
}
SUPER_CONTINUE;
#line 939 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(question_dupe_zero_equals_question_branch)
NEXT_P2;
}

GROUPADD(2)
#endif
LABEL(paren_next) /* (next) ( #a_target R:n1 -- R:n2 ) */
/*  */
NAME("(next)")
{
DEF_CA
Cell * a_target;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397771 ),a_target);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(1);
{
#line 385 "./prim"
n2=n1-1;
#line 384
	#ifdef NO_IP
#line 384
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);

#line 384
#endif
#line 384
if (n1) {
#line 384
	#ifdef NO_IP
#line 384
JUMP(a_target);
#line 384
#else
#line 384
SET_IP((Xt *)a_target);
#line 384
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
 NEXT_P2;
#line 384
#endif
#line 384
}
#line 384
SUPER_CONTINUE;
#line 384
#line 1022 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
LABEL2(paren_next)
NEXT_P2;
}

GROUPADD(1)
#ifdef HAS_GLOCALS
LABEL(paren_next_lp_plus_store_number) /* (next)-lp+!# ( #a_target #nlocals R:n1 -- R:n2 ) */
/*  */
NAME("(next)-lp+!#")
{
DEF_CA
Cell * a_target;
Cell nlocals;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397772 ),a_target);
vm_Cell2n(IMM_ARG(IP[1],305397773 ),nlocals);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlocals=", vm_out); printarg_n(nlocals);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(2);
{
#line 385 "./prim"
n2=n1-1;
#line 384
	#ifdef NO_IP
#line 384
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);

#line 384
#endif
#line 384
if (n1) {
#line 384
	lp += nlocals;
#line 384
#ifdef NO_IP
#line 384
JUMP(a_target);
#line 384
#else
#line 384
SET_IP((Xt *)a_target);
#line 384
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
 NEXT_P2;
#line 384
#endif
#line 384
}
#line 384
SUPER_CONTINUE;
#line 384
#line 1111 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
LABEL2(paren_next_lp_plus_store_number)
NEXT_P2;
}

GROUPADD(1)
#endif
LABEL(paren_loop) /* (loop) ( #a_target R:nlimit R:n1 -- R:nlimit R:n2 ) */
/*  */
NAME("(loop)")
{
DEF_CA
Cell * a_target;
Cell nlimit;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397774 ),a_target);
vm_Cell2n(rp[1],nlimit);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(1);
{
#line 393 "./prim"
n2=n1+1;
#line 392
	#ifdef NO_IP
#line 392
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);

#line 392
#endif
#line 392
if (n2 != nlimit) {
#line 392
	#ifdef NO_IP
#line 392
JUMP(a_target);
#line 392
#else
#line 392
SET_IP((Xt *)a_target);
#line 392
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
 NEXT_P2;
#line 392
#endif
#line 392
}
#line 392
SUPER_CONTINUE;
#line 392
#line 1198 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
LABEL2(paren_loop)
NEXT_P2;
}

GROUPADD(1)
#ifdef HAS_GLOCALS
LABEL(paren_loop_lp_plus_store_number) /* (loop)-lp+!# ( #a_target #nlocals R:nlimit R:n1 -- R:nlimit R:n2 ) */
/*  */
NAME("(loop)-lp+!#")
{
DEF_CA
Cell * a_target;
Cell nlocals;
Cell nlimit;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397775 ),a_target);
vm_Cell2n(IMM_ARG(IP[1],305397776 ),nlocals);
vm_Cell2n(rp[1],nlimit);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlocals=", vm_out); printarg_n(nlocals);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(2);
{
#line 393 "./prim"
n2=n1+1;
#line 392
	#ifdef NO_IP
#line 392
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);

#line 392
#endif
#line 392
if (n2 != nlimit) {
#line 392
	lp += nlocals;
#line 392
#ifdef NO_IP
#line 392
JUMP(a_target);
#line 392
#else
#line 392
SET_IP((Xt *)a_target);
#line 392
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
 NEXT_P2;
#line 392
#endif
#line 392
}
#line 392
SUPER_CONTINUE;
#line 392
#line 1290 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
LABEL2(paren_loop_lp_plus_store_number)
NEXT_P2;
}

GROUPADD(1)
#endif
LABEL(paren_plus_loop) /* (+loop) ( #a_target n R:nlimit R:n1 -- R:nlimit R:n2 ) */
/*  */
NAME("(+loop)")
{
DEF_CA
Cell * a_target;
Cell n;
Cell nlimit;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397777 ),a_target);
vm_Cell2n(spTOS,n);
vm_Cell2n(rp[1],nlimit);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" n=", vm_out); printarg_n(n);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(1);
sp += 1;
{
#line 409 "./prim"
/* !! check this thoroughly */
#line 408
/* sign bit manipulation and test: (x^y)<0 is equivalent to (x<0) != (y<0) */
#line 408
/* dependent upon two's complement arithmetic */
#line 408
Cell olddiff = n1-nlimit;
#line 408
n2=n1+n;	
#line 408
	#ifdef NO_IP
#line 408
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);

#line 408
#endif
#line 408
if ((olddiff^(olddiff+n))>=0   /* the limit is not crossed */
#line 408
    || (olddiff^n)>=0          /* it is a wrap-around effect */) {
#line 408
	#ifdef NO_IP
#line 408
JUMP(a_target);
#line 408
#else
#line 408
SET_IP((Xt *)a_target);
#line 408
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 408
#endif
#line 408
}
#line 408
SUPER_CONTINUE;
#line 408
#line 1393 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_plus_loop)
NEXT_P2;
}

GROUPADD(1)
#ifdef HAS_GLOCALS
LABEL(paren_plus_loop_lp_plus_store_number) /* (+loop)-lp+!# ( #a_target #nlocals n R:nlimit R:n1 -- R:nlimit R:n2 ) */
/*  */
NAME("(+loop)-lp+!#")
{
DEF_CA
Cell * a_target;
Cell nlocals;
Cell n;
Cell nlimit;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397778 ),a_target);
vm_Cell2n(IMM_ARG(IP[1],305397779 ),nlocals);
vm_Cell2n(spTOS,n);
vm_Cell2n(rp[1],nlimit);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlocals=", vm_out); printarg_n(nlocals);
fputs(" n=", vm_out); printarg_n(n);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(2);
sp += 1;
{
#line 409 "./prim"
/* !! check this thoroughly */
#line 408
/* sign bit manipulation and test: (x^y)<0 is equivalent to (x<0) != (y<0) */
#line 408
/* dependent upon two's complement arithmetic */
#line 408
Cell olddiff = n1-nlimit;
#line 408
n2=n1+n;	
#line 408
	#ifdef NO_IP
#line 408
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);

#line 408
#endif
#line 408
if ((olddiff^(olddiff+n))>=0   /* the limit is not crossed */
#line 408
    || (olddiff^n)>=0          /* it is a wrap-around effect */) {
#line 408
	lp += nlocals;
#line 408
#ifdef NO_IP
#line 408
JUMP(a_target);
#line 408
#else
#line 408
SET_IP((Xt *)a_target);
#line 408
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 408
#endif
#line 408
}
#line 408
SUPER_CONTINUE;
#line 408
#line 1502 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_plus_loop_lp_plus_store_number)
NEXT_P2;
}

GROUPADD(1)
#endif
GROUPADD(0)
#ifdef HAS_XCONDS
LABEL(paren_minus_loop) /* (-loop) ( #a_target u R:nlimit R:n1 -- R:nlimit R:n2 ) */
/*  */
NAME("(-loop)")
{
DEF_CA
Cell * a_target;
UCell u;
Cell nlimit;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397780 ),a_target);
vm_Cell2u(spTOS,u);
vm_Cell2n(rp[1],nlimit);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" u=", vm_out); printarg_u(u);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(1);
sp += 1;
{
#line 417 "./prim"
UCell olddiff = n1-nlimit;
#line 416
n2=n1-u;
#line 416
	#ifdef NO_IP
#line 416
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);

#line 416
#endif
#line 416
if (olddiff>u) {
#line 416
	#ifdef NO_IP
#line 416
JUMP(a_target);
#line 416
#else
#line 416
SET_IP((Xt *)a_target);
#line 416
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 416
#endif
#line 416
}
#line 416
SUPER_CONTINUE;
#line 416
#line 1600 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_minus_loop)
NEXT_P2;
}

GROUPADD(1)
#ifdef HAS_GLOCALS
LABEL(paren_minus_loop_lp_plus_store_number) /* (-loop)-lp+!# ( #a_target #nlocals u R:nlimit R:n1 -- R:nlimit R:n2 ) */
/*  */
NAME("(-loop)-lp+!#")
{
DEF_CA
Cell * a_target;
Cell nlocals;
UCell u;
Cell nlimit;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397781 ),a_target);
vm_Cell2n(IMM_ARG(IP[1],305397782 ),nlocals);
vm_Cell2u(spTOS,u);
vm_Cell2n(rp[1],nlimit);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlocals=", vm_out); printarg_n(nlocals);
fputs(" u=", vm_out); printarg_u(u);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(2);
sp += 1;
{
#line 417 "./prim"
UCell olddiff = n1-nlimit;
#line 416
n2=n1-u;
#line 416
	#ifdef NO_IP
#line 416
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);

#line 416
#endif
#line 416
if (olddiff>u) {
#line 416
	lp += nlocals;
#line 416
#ifdef NO_IP
#line 416
JUMP(a_target);
#line 416
#else
#line 416
SET_IP((Xt *)a_target);
#line 416
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 416
#endif
#line 416
}
#line 416
SUPER_CONTINUE;
#line 416
#line 1701 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_minus_loop_lp_plus_store_number)
NEXT_P2;
}

GROUPADD(1)
#endif
LABEL(paren_symmetric_plus_loop) /* (s+loop) ( #a_target n R:nlimit R:n1 -- R:nlimit R:n2 ) */
/* The run-time procedure compiled by S+LOOP. It loops until the index
crosses the boundary between limit and limit-sign(n). I.e. a symmetric
version of (+LOOP). */
NAME("(s+loop)")
{
DEF_CA
Cell * a_target;
Cell n;
Cell nlimit;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397783 ),a_target);
vm_Cell2n(spTOS,n);
vm_Cell2n(rp[1],nlimit);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" n=", vm_out); printarg_n(n);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(1);
sp += 1;
{
#line 432 "./prim"
/* !! check this thoroughly */
#line 431
Cell diff = n1-nlimit;
#line 431
Cell newdiff = diff+n;
#line 431
if (n<0) {
#line 431
    diff = -diff;
#line 431
    newdiff = -newdiff;
#line 431
}
#line 431
n2=n1+n;
#line 431
	#ifdef NO_IP
#line 431
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);

#line 431
#endif
#line 431
if (diff>=0 || newdiff<0) {
#line 431
	#ifdef NO_IP
#line 431
JUMP(a_target);
#line 431
#else
#line 431
SET_IP((Xt *)a_target);
#line 431
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 431
#endif
#line 431
}
#line 431
SUPER_CONTINUE;
#line 431
#line 1811 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_symmetric_plus_loop)
NEXT_P2;
}

GROUPADD(1)
#ifdef HAS_GLOCALS
LABEL(paren_symmetric_plus_loop_lp_plus_store_number) /* (s+loop)-lp+!# ( #a_target #nlocals n R:nlimit R:n1 -- R:nlimit R:n2 ) */
/* The run-time procedure compiled by S+LOOP. It loops until the index
crosses the boundary between limit and limit-sign(n). I.e. a symmetric
version of (+LOOP). */
NAME("(s+loop)-lp+!#")
{
DEF_CA
Cell * a_target;
Cell nlocals;
Cell n;
Cell nlimit;
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2a_(IMM_ARG(IPTOS,305397784 ),a_target);
vm_Cell2n(IMM_ARG(IP[1],305397785 ),nlocals);
vm_Cell2n(spTOS,n);
vm_Cell2n(rp[1],nlimit);
vm_Cell2n(rpTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlocals=", vm_out); printarg_n(nlocals);
fputs(" n=", vm_out); printarg_n(n);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
INC_IP(2);
sp += 1;
{
#line 432 "./prim"
/* !! check this thoroughly */
#line 431
Cell diff = n1-nlimit;
#line 431
Cell newdiff = diff+n;
#line 431
if (n<0) {
#line 431
    diff = -diff;
#line 431
    newdiff = -newdiff;
#line 431
}
#line 431
n2=n1+n;
#line 431
	#ifdef NO_IP
#line 431
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);

#line 431
#endif
#line 431
if (diff>=0 || newdiff<0) {
#line 431
	lp += nlocals;
#line 431
#ifdef NO_IP
#line 431
JUMP(a_target);
#line 431
#else
#line 431
SET_IP((Xt *)a_target);
#line 431
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 431
#endif
#line 431
}
#line 431
SUPER_CONTINUE;
#line 431
#line 1926 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_symmetric_plus_loop_lp_plus_store_number)
NEXT_P2;
}

GROUPADD(1)
#endif
GROUPADD(0)
#endif
LABEL(paren_for) /* (for) ( ncount -- R:nlimit R:ncount ) */
/*  */
NAME("(for)")
{
DEF_CA
Cell ncount;
Cell nlimit;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2n(spTOS,ncount);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ncount=", vm_out); printarg_n(ncount);
}
#endif
sp += 1;
rp += -2;
{
#line 437 "./prim"
/* or (for) = >r -- collides with unloop! */
nlimit=0;
#line 1968 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(ncount,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_for)
NEXT_P2;
}

LABEL(paren_do) /* (do) ( nlimit nstart -- R:nlimit R:nstart ) */
/*  */
NAME("(do)")
{
DEF_CA
Cell nlimit;
Cell nstart;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2n(sp[1],nlimit);
vm_Cell2n(spTOS,nstart);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" nstart=", vm_out); printarg_n(nstart);
}
#endif
sp += 2;
rp += -2;
{
#line 443 "./prim"
#line 2006 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_do)
NEXT_P2;
}

LABEL(paren_question_do) /* (?do) ( #a_target nlimit nstart -- R:nlimit R:nstart ) */
/*  */
NAME("(?do)")
{
DEF_CA
Cell * a_target;
Cell nlimit;
Cell nstart;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397786 ),a_target);
vm_Cell2n(sp[1],nlimit);
vm_Cell2n(spTOS,nstart);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" nstart=", vm_out); printarg_n(nstart);
}
#endif
INC_IP(1);
sp += 2;
rp += -2;
{
#line 447 "./prim"
#ifdef NO_IP
    SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);

#endif
if (nstart == nlimit) {
#ifdef NO_IP
    JUMP(a_target);
#else
    SET_IP((Xt *)a_target);
    SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#endif
}
SUPER_CONTINUE;
#line 2081 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_question_do)
NEXT_P2;
}

GROUPADD(3)
#ifdef HAS_XCONDS
LABEL(paren_plus_do) /* (+do) ( #a_target nlimit nstart -- R:nlimit R:nstart ) */
/*  */
NAME("(+do)")
{
DEF_CA
Cell * a_target;
Cell nlimit;
Cell nstart;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397787 ),a_target);
vm_Cell2n(sp[1],nlimit);
vm_Cell2n(spTOS,nstart);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" nstart=", vm_out); printarg_n(nstart);
}
#endif
INC_IP(1);
sp += 2;
rp += -2;
{
#line 470 "./prim"
#ifdef NO_IP
    SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);

#endif
if (nstart >= nlimit) {
#ifdef NO_IP
    JUMP(a_target);
#else
    SET_IP((Xt *)a_target);
    SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#endif
}
SUPER_CONTINUE;
#line 2159 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_plus_do)
NEXT_P2;
}

LABEL(paren_u_plus_do) /* (u+do) ( #a_target ulimit ustart -- R:ulimit R:ustart ) */
/*  */
NAME("(u+do)")
{
DEF_CA
Cell * a_target;
UCell ulimit;
UCell ustart;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397788 ),a_target);
vm_Cell2u(sp[1],ulimit);
vm_Cell2u(spTOS,ustart);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" ulimit=", vm_out); printarg_u(ulimit);
fputs(" ustart=", vm_out); printarg_u(ustart);
}
#endif
INC_IP(1);
sp += 2;
rp += -2;
{
#line 493 "./prim"
#ifdef NO_IP
    SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(ulimit,rp[1]);
vm_u2Cell(ustart,rpTOS);
IF_spTOS(spTOS = sp[0]);

#endif
if (ustart >= ulimit) {
#ifdef NO_IP
JUMP(a_target);
#else
SET_IP((Xt *)a_target);
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(ulimit,rp[1]);
vm_u2Cell(ustart,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#endif
}
SUPER_CONTINUE;
#line 2235 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(ulimit,rp[1]);
vm_u2Cell(ustart,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_u_plus_do)
NEXT_P2;
}

LABEL(paren_minus_do) /* (-do) ( #a_target nlimit nstart -- R:nlimit R:nstart ) */
/*  */
NAME("(-do)")
{
DEF_CA
Cell * a_target;
Cell nlimit;
Cell nstart;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397789 ),a_target);
vm_Cell2n(sp[1],nlimit);
vm_Cell2n(spTOS,nstart);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" nlimit=", vm_out); printarg_n(nlimit);
fputs(" nstart=", vm_out); printarg_n(nstart);
}
#endif
INC_IP(1);
sp += 2;
rp += -2;
{
#line 516 "./prim"
#ifdef NO_IP
    SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);

#endif
if (nstart <= nlimit) {
#ifdef NO_IP
JUMP(a_target);
#else
SET_IP((Xt *)a_target);
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#endif
}
SUPER_CONTINUE;
#line 2311 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nlimit,rp[1]);
vm_n2Cell(nstart,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_minus_do)
NEXT_P2;
}

LABEL(paren_u_minus_do) /* (u-do) ( #a_target ulimit ustart -- R:ulimit R:ustart ) */
/*  */
NAME("(u-do)")
{
DEF_CA
Cell * a_target;
UCell ulimit;
UCell ustart;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397790 ),a_target);
vm_Cell2u(sp[1],ulimit);
vm_Cell2u(spTOS,ustart);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" ulimit=", vm_out); printarg_u(ulimit);
fputs(" ustart=", vm_out); printarg_u(ustart);
}
#endif
INC_IP(1);
sp += 2;
rp += -2;
{
#line 539 "./prim"
#ifdef NO_IP
    SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(ulimit,rp[1]);
vm_u2Cell(ustart,rpTOS);
IF_spTOS(spTOS = sp[0]);

#endif
if (ustart <= ulimit) {
#ifdef NO_IP
JUMP(a_target);
#else
SET_IP((Xt *)a_target);
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(ulimit,rp[1]);
vm_u2Cell(ustart,rpTOS);
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#endif
}
SUPER_CONTINUE;
#line 2387 "prim.i"
}
SUPER_END;

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(ulimit,rp[1]);
vm_u2Cell(ustart,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_u_minus_do)
NEXT_P2;
}

GROUPADD(4)
#endif
LABEL(i) /* i ( R:n -- R:n n ) */
/*  */
NAME("i")
{
DEF_CA
Cell n;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2n(rpTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += -1;
{
#line 567 "./prim"
#line 2423 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(i)
NEXT_P2;
}

LABEL(i_tick) /* i' ( R:w R:w2 -- R:w R:w2 w ) */
/*  */
NAME("i'")
{
DEF_CA
Cell w;
Cell w2;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2w(rp[1],w);
vm_Cell2w(rpTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += -1;
{
#line 572 "./prim"
#line 2457 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(i_tick)
NEXT_P2;
}

LABEL(j) /* j ( R:n R:d1 -- n R:n R:d1 ) */
/*  */
NAME("j")
{
DEF_CA
Cell n;
DCell d1;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2n(rp[2],n);
vm_twoCell2d((Cell)rp[1], (Cell)rpTOS, d1)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
fputs(" d1=", vm_out); printarg_d(d1);
}
#endif
sp += -1;
{
#line 578 "./prim"
#line 2491 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
vm_d2twoCell(d1, rp[1], rpTOS)
LABEL2(j)
NEXT_P2;
}

LABEL(k) /* k ( R:n R:d1 R:d2 -- n R:n R:d1 R:d2 ) */
/*  */
NAME("k")
{
DEF_CA
Cell n;
DCell d1;
DCell d2;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2n(rp[4],n);
vm_twoCell2d((Cell)rp[3], (Cell)rp[2], d1)
vm_twoCell2d((Cell)rp[1], (Cell)rpTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += -1;
{
#line 584 "./prim"
#line 2529 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
vm_d2twoCell(d1, rp[3], rp[2])
vm_d2twoCell(d2, rp[1], rpTOS)
LABEL2(k)
NEXT_P2;
}

GROUPADD(4)
GROUP( strings, 43)
LABEL(move) /* move ( c_from c_to ucount -- ) */
/* Copy the contents of @i{ucount} aus at @i{c-from} to
@i{c-to}. @code{move} works correctly even if the two areas overlap. */
NAME("move")
{
DEF_CA
Char * c_from;
Char * c_to;
UCell ucount;
NEXT_P0;
vm_Cell2c_(sp[2],c_from);
vm_Cell2c_(sp[1],c_to);
vm_Cell2u(spTOS,ucount);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_from=", vm_out); printarg_c_(c_from);
fputs(" c_to=", vm_out); printarg_c_(c_to);
fputs(" ucount=", vm_out); printarg_u(ucount);
}
#endif
sp += 3;
{
#line 598 "./prim"
/* !! note that the standard specifies addr, not c-addr */
memmove(c_to,c_from,ucount);
/* make an Ifdef for bsd and others? */
#line 2573 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(move)
NEXT_P2;
}

LABEL(c_move) /* cmove ( c_from c_to u -- ) */
/* Copy the contents of @i{ucount} characters from data space at
@i{c-from} to @i{c-to}. The copy proceeds @code{char}-by-@code{char}
from low address to high address; i.e., for overlapping areas it is
safe if @i{c-to}=<@i{c-from}. */
NAME("cmove")
{
DEF_CA
Char * c_from;
Char * c_to;
UCell u;
NEXT_P0;
vm_Cell2c_(sp[2],c_from);
vm_Cell2c_(sp[1],c_to);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_from=", vm_out); printarg_c_(c_from);
fputs(" c_to=", vm_out); printarg_c_(c_to);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 3;
{
#line 609 "./prim"
cmove(c_from,c_to,u);
#line 2613 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(c_move)
NEXT_P2;
}

LABEL(c_move_up) /* cmove> ( c_from c_to u -- ) */
/* Copy the contents of @i{ucount} characters from data space at
@i{c-from} to @i{c-to}. The copy proceeds @code{char}-by-@code{char}
from high address to low address; i.e., for overlapping areas it is
safe if @i{c-to}>=@i{c-from}. */
NAME("cmove>")
{
DEF_CA
Char * c_from;
Char * c_to;
UCell u;
NEXT_P0;
vm_Cell2c_(sp[2],c_from);
vm_Cell2c_(sp[1],c_to);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_from=", vm_out); printarg_c_(c_from);
fputs(" c_to=", vm_out); printarg_c_(c_to);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 3;
{
#line 618 "./prim"
cmove_up(c_from,c_to,u);
#line 2653 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(c_move_up)
NEXT_P2;
}

LABEL(fill) /* fill ( c_addr u c -- ) */
/* Store @i{c} in @i{u} chars starting at @i{c-addr}. */
NAME("fill")
{
DEF_CA
Char * c_addr;
UCell u;
Char c;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2c(spTOS,c);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" c=", vm_out); printarg_c(c);
}
#endif
sp += 3;
{
#line 626 "./prim"
memset(c_addr,c,u);
#line 2690 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(fill)
NEXT_P2;
}

LABEL(compare) /* compare ( c_addr1 u1 c_addr2 u2 -- n ) */
/* Compare two strings lexicographically. If they are equal, @i{n} is 0; if
the first string is smaller, @i{n} is -1; if the first string is larger, @i{n}
is 1. Currently this is based on the machine's character
comparison. In the future, this may change to consider the current
locale and its collation order. */
NAME("compare")
{
DEF_CA
Char * c_addr1;
UCell u1;
Char * c_addr2;
UCell u2;
Cell n;
NEXT_P0;
vm_Cell2c_(sp[3],c_addr1);
vm_Cell2u(sp[2],u1);
vm_Cell2c_(sp[1],c_addr2);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" c_addr2=", vm_out); printarg_c_(c_addr2);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 3;
{
#line 637 "./prim"
/* close ' to keep fontify happy */ 
n = compare(c_addr1, u1, c_addr2, u2);
#line 2736 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(compare)
NEXT_P2;
}

LABEL(toupper) /* toupper ( c1 -- c2 ) */
/* If @i{c1} is a lower-case character (in the current locale), @i{c2}
is the equivalent upper-case character. All other characters are unchanged. */
NAME("toupper")
{
DEF_CA
Char c1;
Char c2;
NEXT_P0;
vm_Cell2c(spTOS,c1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c1=", vm_out); printarg_c(c1);
}
#endif
{
#line 662 "./prim"
c2 = toupper(c1);
#line 2769 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c2=", vm_out); printarg_c(c2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c2Cell(c2,spTOS);
LABEL2(toupper)
NEXT_P2;
}

LABEL(slash_string) /* /string ( c_addr1 u1 n -- c_addr2 u2 ) */
/* Adjust the string specified by @i{c-addr1, u1} to remove @i{n}
characters from the start of the string. */
NAME("/string")
{
DEF_CA
Char * c_addr1;
UCell u1;
Cell n;
Char * c_addr2;
UCell u2;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr1);
vm_Cell2u(sp[1],u1);
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += 1;
{
#line 669 "./prim"
c_addr2 = c_addr1+n;
u2 = u1-n;
#line 2811 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr2=", vm_out); printarg_c_(c_addr2);
fputs(" u2=", vm_out); printarg_u(u2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr2,sp[1]);
vm_u2Cell(u2,spTOS);
LABEL2(slash_string)
NEXT_P2;
}

GROUPADD(7)
GROUP( arith, 50)
LABEL(lit) /* lit ( #w -- w ) */
/*  */
NAME("lit")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2w(IMM_ARG(IPTOS,305397791 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(1);
sp += -1;
{
#line 677 "./prim"
#line 2848 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(lit)
NEXT_P2;
}

LABEL(plus) /* + ( n1 n2 -- n ) */
/*  */
NAME("+")
{
DEF_CA
Cell n1;
Cell n2;
Cell n;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 681 "./prim"
n = n1+n2;
#line 2883 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(plus)
NEXT_P2;
}

LABEL(lit_plus) /* lit+ ( n1 #n2 -- n ) */
/*  */
NAME("lit+")
{
DEF_CA
Cell n1;
Cell n2;
Cell n;
NEXT_P0;
vm_Cell2n(spTOS,n1);
vm_Cell2n(IMM_ARG(IPTOS,305397792 ),n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
INC_IP(1);
{
#line 686 "./prim"
n=n1+n2;
#line 2919 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(lit_plus)
NEXT_P2;
}

LABEL(under_plus) /* under+ ( n1 n2 n3 -- n n2 ) */
/* add @i{n3} to @i{n1} (giving @i{n}) */
NAME("under+")
{
DEF_CA
Cell n1;
Cell n2;
Cell n3;
Cell n;
NEXT_P0;
vm_Cell2n(sp[2],n1);
vm_Cell2n(sp[1],n2);
vm_Cell2n(spTOS,n3);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
fputs(" n3=", vm_out); printarg_n(n3);
}
#endif
sp += 1;
{
#line 691 "./prim"
n = n1+n3;
#line 2958 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,sp[1]);
IF_spTOS(vm_n2Cell(n2,spTOS););
LABEL2(under_plus)
NEXT_P2;
}

LABEL(minus) /* - ( n1 n2 -- n ) */
/*  */
NAME("-")
{
DEF_CA
Cell n1;
Cell n2;
Cell n;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 696 "./prim"
n = n1-n2;
#line 2995 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(minus)
NEXT_P2;
}

LABEL(negate) /* negate ( n1 -- n2 ) */
/*  */
NAME("negate")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 701 "./prim"
/* use minus as alias */
n2 = -n1;
#line 3028 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(negate)
NEXT_P2;
}

LABEL(one_plus) /* 1+ ( n1 -- n2 ) */
/*  */
NAME("1+")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 707 "./prim"
n2 = n1+1;
#line 3060 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(one_plus)
NEXT_P2;
}

LABEL(one_minus) /* 1- ( n1 -- n2 ) */
/*  */
NAME("1-")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 712 "./prim"
n2 = n1-1;
#line 3092 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(one_minus)
NEXT_P2;
}

LABEL(max) /* max ( n1 n2 -- n ) */
/*  */
NAME("max")
{
DEF_CA
Cell n1;
Cell n2;
Cell n;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 717 "./prim"
if (n1<n2)
  n = n2;
else
  n = n1;
#line 3131 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(max)
NEXT_P2;
}

LABEL(min) /* min ( n1 n2 -- n ) */
/*  */
NAME("min")
{
DEF_CA
Cell n1;
Cell n2;
Cell n;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 725 "./prim"
if (n1<n2)
  n = n1;
else
  n = n2;
#line 3170 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(min)
NEXT_P2;
}

LABEL(abs) /* abs ( n -- u ) */
/*  */
NAME("abs")
{
DEF_CA
Cell n;
UCell u;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
{
#line 733 "./prim"
if (n<0)
  u = -n;
else
  u = n;
#line 3205 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u=", vm_out); printarg_u(u);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u,spTOS);
LABEL2(abs)
NEXT_P2;
}

LABEL(star) /* * ( n1 n2 -- n ) */
/*  */
NAME("*")
{
DEF_CA
Cell n1;
Cell n2;
Cell n;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 741 "./prim"
n = n1*n2;
#line 3241 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(star)
NEXT_P2;
}

LABEL(slash) /* / ( n1 n2 -- n ) */
/*  */
NAME("/")
{
DEF_CA
Cell n1;
Cell n2;
Cell n;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 746 "./prim"
n = n1/n2;
#line 3277 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(slash)
NEXT_P2;
}

LABEL(mod) /* mod ( n1 n2 -- n ) */
/*  */
NAME("mod")
{
DEF_CA
Cell n1;
Cell n2;
Cell n;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 751 "./prim"
n = n1%n2;
#line 3313 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(mod)
NEXT_P2;
}

LABEL(slash_mod) /* /mod ( n1 n2 -- n3 n4 ) */
/*  */
NAME("/mod")
{
DEF_CA
Cell n1;
Cell n2;
Cell n3;
Cell n4;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
{
#line 756 "./prim"
n4 = n1/n2;
n3 = n1%n2; /* !! is this correct? look into C standard! */
#line 3350 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n3=", vm_out); printarg_n(n3);
fputs(" n4=", vm_out); printarg_n(n4);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n3,sp[1]);
vm_n2Cell(n4,spTOS);
LABEL2(slash_mod)
NEXT_P2;
}

LABEL(two_star) /* 2* ( n1 -- n2 ) */
/* Shift left by 1; also works on unsigned numbers */
NAME("2*")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 763 "./prim"
n2 = 2*n1;
#line 3384 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(two_star)
NEXT_P2;
}

LABEL(two_slash) /* 2/ ( n1 -- n2 ) */
/* Arithmetic shift right by 1.  For signed numbers this is a floored
division by 2 (note that @code{/} not necessarily floors). */
NAME("2/")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 770 "./prim"
n2 = n1>>1;
#line 3417 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(two_slash)
NEXT_P2;
}

LABEL(f_m_slash_mod) /* fm/mod ( d1 n1 -- n2 n3 ) */
/* Floored division: @i{d1} = @i{n3}*@i{n1}+@i{n2}, @i{n1}>@i{n2}>=0 or 0>=@i{n2}>@i{n1}. */
NAME("fm/mod")
{
DEF_CA
DCell d1;
Cell n1;
Cell n2;
Cell n3;
NEXT_P0;
vm_twoCell2d((Cell)sp[2], (Cell)sp[1], d1)
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
sp += 1;
{
#line 780 "./prim"
#ifdef BUGGY_LONG_LONG
DCell r = fmdiv(d1,n1);
n2=r.hi;
n3=r.lo;
#else
/* assumes that the processor uses either floored or symmetric division */
n3 = d1/n1;
n2 = d1%n1;
/* note that this 1%-3>0 is optimized by the compiler */
if (1%-3>0 && (d1<0) != (n1<0) && n2!=0) {
  n3--;
  n2+=n1;
}
#endif
#line 3467 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputs(" n3=", vm_out); printarg_n(n3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,sp[1]);
vm_n2Cell(n3,spTOS);
LABEL2(f_m_slash_mod)
NEXT_P2;
}

LABEL(s_m_slash_rem) /* sm/rem ( d1 n1 -- n2 n3 ) */
/* Symmetric division: @i{d1} = @i{n3}*@i{n1}+@i{n2}, sign(@i{n2})=sign(@i{d1}) or 0. */
NAME("sm/rem")
{
DEF_CA
DCell d1;
Cell n1;
Cell n2;
Cell n3;
NEXT_P0;
vm_twoCell2d((Cell)sp[2], (Cell)sp[1], d1)
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
sp += 1;
{
#line 802 "./prim"
#ifdef BUGGY_LONG_LONG
DCell r = smdiv(d1,n1);
n2=r.hi;
n3=r.lo;
#else
/* assumes that the processor uses either floored or symmetric division */
n3 = d1/n1;
n2 = d1%n1;
/* note that this 1%-3<0 is optimized by the compiler */
if (1%-3<0 && (d1<0) != (n1<0) && n2!=0) {
  n3++;
  n2-=n1;
}
#endif
#line 3519 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputs(" n3=", vm_out); printarg_n(n3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,sp[1]);
vm_n2Cell(n3,spTOS);
LABEL2(s_m_slash_rem)
NEXT_P2;
}

LABEL(m_star) /* m* ( n1 n2 -- d ) */
/*  */
NAME("m*")
{
DEF_CA
Cell n1;
Cell n2;
DCell d;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
{
#line 823 "./prim"
#ifdef BUGGY_LONG_LONG
d = mmul(n1,n2);
#else
d = (DCell)n1 * (DCell)n2;
#endif
#line 3560 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d=", vm_out); printarg_d(d);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, sp[1], spTOS)
LABEL2(m_star)
NEXT_P2;
}

LABEL(u_m_star) /* um* ( u1 u2 -- ud ) */
/*  */
NAME("um*")
{
DEF_CA
UCell u1;
UCell u2;
UDCell ud;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
{
#line 834 "./prim"
/* use u* as alias */
#ifdef BUGGY_LONG_LONG
ud = ummul(u1,u2);
#else
ud = (UDCell)u1 * (UDCell)u2;
#endif
#line 3600 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" ud=", vm_out); printarg_ud(ud);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_ud2twoCell(ud, sp[1], spTOS)
LABEL2(u_m_star)
NEXT_P2;
}

LABEL(u_m_slash_mod) /* um/mod ( ud u1 -- u2 u3 ) */
/* ud=u3*u1+u2, u1>u2>=0 */
NAME("um/mod")
{
DEF_CA
UDCell ud;
UCell u1;
UCell u2;
UCell u3;
NEXT_P0;
vm_twoCell2ud((Cell)sp[2], (Cell)sp[1], ud)
vm_Cell2u(spTOS,u1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud=", vm_out); printarg_ud(ud);
fputs(" u1=", vm_out); printarg_u(u1);
}
#endif
sp += 1;
{
#line 851 "./prim"
#ifdef BUGGY_LONG_LONG
UDCell r = umdiv(ud,u1);
u2=r.hi;
u3=r.lo;
#else
u3 = ud/u1;
u2 = ud%u1;
#endif
#line 3644 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u2,sp[1]);
vm_u2Cell(u3,spTOS);
LABEL2(u_m_slash_mod)
NEXT_P2;
}

LABEL(m_plus) /* m+ ( d1 n -- d2 ) */
/*  */
NAME("m+")
{
DEF_CA
DCell d1;
Cell n;
DCell d2;
NEXT_P0;
vm_twoCell2d((Cell)sp[2], (Cell)sp[1], d1)
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += 1;
{
#line 870 "./prim"
#ifdef BUGGY_LONG_LONG
d2.lo = d1.lo+n;
d2.hi = d1.hi - (n<0) + (d2.lo<d1.lo);
#else
d2 = d1+n;
#endif
#line 3687 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d2=", vm_out); printarg_d(d2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d2, sp[1], spTOS)
LABEL2(m_plus)
NEXT_P2;
}

LABEL(d_plus) /* d+ ( d1 d2 -- d ) */
/*  */
NAME("d+")
{
DEF_CA
DCell d1;
DCell d2;
DCell d;
NEXT_P0;
vm_twoCell2d((Cell)sp[3], (Cell)sp[2], d1)
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += 2;
{
#line 880 "./prim"
#ifdef BUGGY_LONG_LONG
d.lo = d1.lo+d2.lo;
d.hi = d1.hi + d2.hi + (d.lo<d1.lo);
#else
d = d1+d2;
#endif
#line 3728 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d=", vm_out); printarg_d(d);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, sp[1], spTOS)
LABEL2(d_plus)
NEXT_P2;
}

LABEL(d_minus) /* d- ( d1 d2 -- d ) */
/*  */
NAME("d-")
{
DEF_CA
DCell d1;
DCell d2;
DCell d;
NEXT_P0;
vm_twoCell2d((Cell)sp[3], (Cell)sp[2], d1)
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += 2;
{
#line 890 "./prim"
#ifdef BUGGY_LONG_LONG
d.lo = d1.lo - d2.lo;
d.hi = d1.hi-d2.hi-(d1.lo<d2.lo);
#else
d = d1-d2;
#endif
#line 3769 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d=", vm_out); printarg_d(d);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, sp[1], spTOS)
LABEL2(d_minus)
NEXT_P2;
}

LABEL(d_negate) /* dnegate ( d1 -- d2 ) */
/*  */
NAME("dnegate")
{
DEF_CA
DCell d1;
DCell d2;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d1)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
}
#endif
{
#line 900 "./prim"
/* use dminus as alias */
#ifdef BUGGY_LONG_LONG
d2 = dnegate(d1);
#else
d2 = -d1;
#endif
#line 3806 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d2=", vm_out); printarg_d(d2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d2, sp[1], spTOS)
LABEL2(d_negate)
NEXT_P2;
}

LABEL(d_two_star) /* d2* ( d1 -- d2 ) */
/* Shift left by 1; also works on unsigned numbers */
NAME("d2*")
{
DEF_CA
DCell d1;
DCell d2;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d1)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
}
#endif
{
#line 911 "./prim"
#ifdef BUGGY_LONG_LONG
d2.lo = d1.lo<<1;
d2.hi = (d1.hi<<1) | (d1.lo>>(CELL_BITS-1));
#else
d2 = 2*d1;
#endif
#line 3843 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d2=", vm_out); printarg_d(d2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d2, sp[1], spTOS)
LABEL2(d_two_star)
NEXT_P2;
}

LABEL(d_two_slash) /* d2/ ( d1 -- d2 ) */
/* Arithmetic shift right by 1.  For signed numbers this is a floored
division by 2. */
NAME("d2/")
{
DEF_CA
DCell d1;
DCell d2;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d1)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
}
#endif
{
#line 923 "./prim"
#ifdef BUGGY_LONG_LONG
d2.hi = d1.hi>>1;
d2.lo= (d1.lo>>1) | (d1.hi<<(CELL_BITS-1));
#else
d2 = d1>>1;
#endif
#line 3881 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d2=", vm_out); printarg_d(d2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d2, sp[1], spTOS)
LABEL2(d_two_slash)
NEXT_P2;
}

LABEL(and) /* and ( w1 w2 -- w ) */
/*  */
NAME("and")
{
DEF_CA
Cell w1;
Cell w2;
Cell w;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += 1;
{
#line 934 "./prim"
w = w1&w2;
#line 3917 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(and)
NEXT_P2;
}

LABEL(or) /* or ( w1 w2 -- w ) */
/*  */
NAME("or")
{
DEF_CA
Cell w1;
Cell w2;
Cell w;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += 1;
{
#line 937 "./prim"
w = w1|w2;
#line 3953 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(or)
NEXT_P2;
}

LABEL(x_or) /* xor ( w1 w2 -- w ) */
/*  */
NAME("xor")
{
DEF_CA
Cell w1;
Cell w2;
Cell w;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += 1;
{
#line 942 "./prim"
w = w1^w2;
#line 3989 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(x_or)
NEXT_P2;
}

LABEL(invert) /* invert ( w1 -- w2 ) */
/*  */
NAME("invert")
{
DEF_CA
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2w(spTOS,w1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
}
#endif
{
#line 945 "./prim"
w2 = ~w1;
#line 4021 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w2=", vm_out); printarg_w(w2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w2,spTOS);
LABEL2(invert)
NEXT_P2;
}

LABEL(r_shift) /* rshift ( u1 n -- u2 ) */
/* Logical shift right by @i{n} bits. */
NAME("rshift")
{
DEF_CA
UCell u1;
Cell n;
UCell u2;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += 1;
{
#line 951 "./prim"
  u2 = u1>>n;
#line 4057 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u2=", vm_out); printarg_u(u2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u2,spTOS);
LABEL2(r_shift)
NEXT_P2;
}

LABEL(l_shift) /* lshift ( u1 n -- u2 ) */
/*  */
NAME("lshift")
{
DEF_CA
UCell u1;
Cell n;
UCell u2;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += 1;
{
#line 956 "./prim"
  u2 = u1<<n;
#line 4093 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u2=", vm_out); printarg_u(u2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u2,spTOS);
LABEL2(l_shift)
NEXT_P2;
}

GROUPADD(34)
GROUP( compare, 84)
LABEL(zero_equals) /* 0= ( n -- f ) */
/*  */
NAME("0=")
{
DEF_CA
Cell n;
Bool f;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
{
#line 1013 "./prim"
f = FLAG(n==0);
#line 1012
#line 4128 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(zero_equals)
NEXT_P2;
}

LABEL(zero_not_equals) /* 0<> ( n -- f ) */
/*  */
NAME("0<>")
{
DEF_CA
Cell n;
Bool f;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
{
#line 1013 "./prim"
f = FLAG(n!=0);
#line 1012
#line 4161 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(zero_not_equals)
NEXT_P2;
}

LABEL(zero_less_than) /* 0< ( n -- f ) */
/*  */
NAME("0<")
{
DEF_CA
Cell n;
Bool f;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
{
#line 1013 "./prim"
f = FLAG(n<0);
#line 1012
#line 4194 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(zero_less_than)
NEXT_P2;
}

LABEL(zero_greater_than) /* 0> ( n -- f ) */
/*  */
NAME("0>")
{
DEF_CA
Cell n;
Bool f;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
{
#line 1013 "./prim"
f = FLAG(n>0);
#line 1012
#line 4227 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(zero_greater_than)
NEXT_P2;
}

LABEL(zero_less_or_equal) /* 0<= ( n -- f ) */
/*  */
NAME("0<=")
{
DEF_CA
Cell n;
Bool f;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
{
#line 1013 "./prim"
f = FLAG(n<=0);
#line 1012
#line 4260 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(zero_less_or_equal)
NEXT_P2;
}

LABEL(zero_greater_or_equal) /* 0>= ( n -- f ) */
/*  */
NAME("0>=")
{
DEF_CA
Cell n;
Bool f;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
{
#line 1013 "./prim"
f = FLAG(n>=0);
#line 1012
#line 4293 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(zero_greater_or_equal)
NEXT_P2;
}

LABEL(equals) /* = ( n1 n2 -- f ) */
/*  */
NAME("=")
{
DEF_CA
Cell n1;
Cell n2;
Bool f;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 1014 "./prim"
f = FLAG(n1==n2);
#line 1013
#line 4330 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(equals)
NEXT_P2;
}

LABEL(not_equals) /* <> ( n1 n2 -- f ) */
/*  */
NAME("<>")
{
DEF_CA
Cell n1;
Cell n2;
Bool f;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 1014 "./prim"
f = FLAG(n1!=n2);
#line 1013
#line 4367 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(not_equals)
NEXT_P2;
}

LABEL(less_than) /* < ( n1 n2 -- f ) */
/*  */
NAME("<")
{
DEF_CA
Cell n1;
Cell n2;
Bool f;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 1014 "./prim"
f = FLAG(n1<n2);
#line 1013
#line 4404 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(less_than)
NEXT_P2;
}

LABEL(greater_than) /* > ( n1 n2 -- f ) */
/*  */
NAME(">")
{
DEF_CA
Cell n1;
Cell n2;
Bool f;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 1014 "./prim"
f = FLAG(n1>n2);
#line 1013
#line 4441 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(greater_than)
NEXT_P2;
}

LABEL(less_or_equal) /* <= ( n1 n2 -- f ) */
/*  */
NAME("<=")
{
DEF_CA
Cell n1;
Cell n2;
Bool f;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 1014 "./prim"
f = FLAG(n1<=n2);
#line 1013
#line 4478 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(less_or_equal)
NEXT_P2;
}

LABEL(greater_or_equal) /* >= ( n1 n2 -- f ) */
/*  */
NAME(">=")
{
DEF_CA
Cell n1;
Cell n2;
Bool f;
NEXT_P0;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 1014 "./prim"
f = FLAG(n1>=n2);
#line 1013
#line 4515 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(greater_or_equal)
NEXT_P2;
}

LABEL(u_equals) /* u= ( u1 u2 -- f ) */
/*  */
NAME("u=")
{
DEF_CA
UCell u1;
UCell u2;
Bool f;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 1;
{
#line 1015 "./prim"
f = FLAG(u1==u2);
#line 1014
#line 4552 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(u_equals)
NEXT_P2;
}

LABEL(u_not_equals) /* u<> ( u1 u2 -- f ) */
/*  */
NAME("u<>")
{
DEF_CA
UCell u1;
UCell u2;
Bool f;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 1;
{
#line 1015 "./prim"
f = FLAG(u1!=u2);
#line 1014
#line 4589 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(u_not_equals)
NEXT_P2;
}

LABEL(u_less_than) /* u< ( u1 u2 -- f ) */
/*  */
NAME("u<")
{
DEF_CA
UCell u1;
UCell u2;
Bool f;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 1;
{
#line 1015 "./prim"
f = FLAG(u1<u2);
#line 1014
#line 4626 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(u_less_than)
NEXT_P2;
}

LABEL(u_greater_than) /* u> ( u1 u2 -- f ) */
/*  */
NAME("u>")
{
DEF_CA
UCell u1;
UCell u2;
Bool f;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 1;
{
#line 1015 "./prim"
f = FLAG(u1>u2);
#line 1014
#line 4663 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(u_greater_than)
NEXT_P2;
}

LABEL(u_less_or_equal) /* u<= ( u1 u2 -- f ) */
/*  */
NAME("u<=")
{
DEF_CA
UCell u1;
UCell u2;
Bool f;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 1;
{
#line 1015 "./prim"
f = FLAG(u1<=u2);
#line 1014
#line 4700 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(u_less_or_equal)
NEXT_P2;
}

LABEL(u_greater_or_equal) /* u>= ( u1 u2 -- f ) */
/*  */
NAME("u>=")
{
DEF_CA
UCell u1;
UCell u2;
Bool f;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 1;
{
#line 1015 "./prim"
f = FLAG(u1>=u2);
#line 1014
#line 4737 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(u_greater_or_equal)
NEXT_P2;
}

GROUPADD(18)
#ifdef HAS_DCOMPS
LABEL(d_equals) /* d= ( d1 d2 -- f ) */
/*  */
NAME("d=")
{
DEF_CA
DCell d1;
DCell d2;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[3], (Cell)sp[2], d1)
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += 3;
{
#line 1065 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1064
f = FLAG(d1.lo==d2.lo && d1.hi==d2.hi);
#line 1064
#else
#line 1064
f = FLAG(d1==d2);
#line 1064
#endif
#line 1064
#line 4784 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_equals)
NEXT_P2;
}

LABEL(d_not_equals) /* d<> ( d1 d2 -- f ) */
/*  */
NAME("d<>")
{
DEF_CA
DCell d1;
DCell d2;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[3], (Cell)sp[2], d1)
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += 3;
{
#line 1065 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1064
f = FLAG(d1.lo!=d2.lo || d1.hi!=d2.hi);
#line 1064
#else
#line 1064
f = FLAG(d1!=d2);
#line 1064
#endif
#line 1064
#line 4829 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_not_equals)
NEXT_P2;
}

LABEL(d_less_than) /* d< ( d1 d2 -- f ) */
/*  */
NAME("d<")
{
DEF_CA
DCell d1;
DCell d2;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[3], (Cell)sp[2], d1)
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += 3;
{
#line 1065 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1064
f = FLAG(d1.hi==d2.hi ? d1.lo<d2.lo : d1.hi<d2.hi);
#line 1064
#else
#line 1064
f = FLAG(d1<d2);
#line 1064
#endif
#line 1064
#line 4874 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_less_than)
NEXT_P2;
}

LABEL(d_greater_than) /* d> ( d1 d2 -- f ) */
/*  */
NAME("d>")
{
DEF_CA
DCell d1;
DCell d2;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[3], (Cell)sp[2], d1)
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += 3;
{
#line 1065 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1064
f = FLAG(d1.hi==d2.hi ? d1.lo>d2.lo : d1.hi>d2.hi);
#line 1064
#else
#line 1064
f = FLAG(d1>d2);
#line 1064
#endif
#line 1064
#line 4919 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_greater_than)
NEXT_P2;
}

LABEL(d_less_or_equal) /* d<= ( d1 d2 -- f ) */
/*  */
NAME("d<=")
{
DEF_CA
DCell d1;
DCell d2;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[3], (Cell)sp[2], d1)
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += 3;
{
#line 1065 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1064
f = FLAG(d1.hi==d2.hi ? d1.lo<=d2.lo : d1.hi<=d2.hi);
#line 1064
#else
#line 1064
f = FLAG(d1<=d2);
#line 1064
#endif
#line 1064
#line 4964 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_less_or_equal)
NEXT_P2;
}

LABEL(d_greater_or_equal) /* d>= ( d1 d2 -- f ) */
/*  */
NAME("d>=")
{
DEF_CA
DCell d1;
DCell d2;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[3], (Cell)sp[2], d1)
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d1=", vm_out); printarg_d(d1);
fputs(" d2=", vm_out); printarg_d(d2);
}
#endif
sp += 3;
{
#line 1065 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1064
f = FLAG(d1.hi==d2.hi ? d1.lo>=d2.lo : d1.hi>=d2.hi);
#line 1064
#else
#line 1064
f = FLAG(d1>=d2);
#line 1064
#endif
#line 1064
#line 5009 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_greater_or_equal)
NEXT_P2;
}

LABEL(d_zero_equals) /* d0= ( d -- f ) */
/*  */
NAME("d0=")
{
DEF_CA
DCell d;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 1;
{
#line 1066 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1065
f = FLAG(d.lo==DZERO.lo && d.hi==DZERO.hi);
#line 1065
#else
#line 1065
f = FLAG(d==DZERO);
#line 1065
#endif
#line 1065
#line 5051 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_zero_equals)
NEXT_P2;
}

LABEL(d_zero_not_equals) /* d0<> ( d -- f ) */
/*  */
NAME("d0<>")
{
DEF_CA
DCell d;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 1;
{
#line 1066 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1065
f = FLAG(d.lo!=DZERO.lo || d.hi!=DZERO.hi);
#line 1065
#else
#line 1065
f = FLAG(d!=DZERO);
#line 1065
#endif
#line 1065
#line 5093 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_zero_not_equals)
NEXT_P2;
}

LABEL(d_zero_less_than) /* d0< ( d -- f ) */
/*  */
NAME("d0<")
{
DEF_CA
DCell d;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 1;
{
#line 1066 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1065
f = FLAG(d.hi==DZERO.hi ? d.lo<DZERO.lo : d.hi<DZERO.hi);
#line 1065
#else
#line 1065
f = FLAG(d<DZERO);
#line 1065
#endif
#line 1065
#line 5135 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_zero_less_than)
NEXT_P2;
}

LABEL(d_zero_greater_than) /* d0> ( d -- f ) */
/*  */
NAME("d0>")
{
DEF_CA
DCell d;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 1;
{
#line 1066 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1065
f = FLAG(d.hi==DZERO.hi ? d.lo>DZERO.lo : d.hi>DZERO.hi);
#line 1065
#else
#line 1065
f = FLAG(d>DZERO);
#line 1065
#endif
#line 1065
#line 5177 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_zero_greater_than)
NEXT_P2;
}

LABEL(d_zero_less_or_equal) /* d0<= ( d -- f ) */
/*  */
NAME("d0<=")
{
DEF_CA
DCell d;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 1;
{
#line 1066 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1065
f = FLAG(d.hi==DZERO.hi ? d.lo<=DZERO.lo : d.hi<=DZERO.hi);
#line 1065
#else
#line 1065
f = FLAG(d<=DZERO);
#line 1065
#endif
#line 1065
#line 5219 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_zero_less_or_equal)
NEXT_P2;
}

LABEL(d_zero_greater_or_equal) /* d0>= ( d -- f ) */
/*  */
NAME("d0>=")
{
DEF_CA
DCell d;
Bool f;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 1;
{
#line 1066 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1065
f = FLAG(d.hi==DZERO.hi ? d.lo>=DZERO.lo : d.hi>=DZERO.hi);
#line 1065
#else
#line 1065
f = FLAG(d>=DZERO);
#line 1065
#endif
#line 1065
#line 5261 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_zero_greater_or_equal)
NEXT_P2;
}

LABEL(d_u_equals) /* du= ( ud1 ud2 -- f ) */
/*  */
NAME("du=")
{
DEF_CA
UDCell ud1;
UDCell ud2;
Bool f;
NEXT_P0;
vm_twoCell2ud((Cell)sp[3], (Cell)sp[2], ud1)
vm_twoCell2ud((Cell)sp[1], (Cell)spTOS, ud2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud1=", vm_out); printarg_ud(ud1);
fputs(" ud2=", vm_out); printarg_ud(ud2);
}
#endif
sp += 3;
{
#line 1067 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1066
f = FLAG(ud1.lo==ud2.lo && ud1.hi==ud2.hi);
#line 1066
#else
#line 1066
f = FLAG(ud1==ud2);
#line 1066
#endif
#line 1066
#line 5306 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_u_equals)
NEXT_P2;
}

LABEL(d_u_not_equals) /* du<> ( ud1 ud2 -- f ) */
/*  */
NAME("du<>")
{
DEF_CA
UDCell ud1;
UDCell ud2;
Bool f;
NEXT_P0;
vm_twoCell2ud((Cell)sp[3], (Cell)sp[2], ud1)
vm_twoCell2ud((Cell)sp[1], (Cell)spTOS, ud2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud1=", vm_out); printarg_ud(ud1);
fputs(" ud2=", vm_out); printarg_ud(ud2);
}
#endif
sp += 3;
{
#line 1067 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1066
f = FLAG(ud1.lo!=ud2.lo || ud1.hi!=ud2.hi);
#line 1066
#else
#line 1066
f = FLAG(ud1!=ud2);
#line 1066
#endif
#line 1066
#line 5351 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_u_not_equals)
NEXT_P2;
}

LABEL(d_u_less_than) /* du< ( ud1 ud2 -- f ) */
/*  */
NAME("du<")
{
DEF_CA
UDCell ud1;
UDCell ud2;
Bool f;
NEXT_P0;
vm_twoCell2ud((Cell)sp[3], (Cell)sp[2], ud1)
vm_twoCell2ud((Cell)sp[1], (Cell)spTOS, ud2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud1=", vm_out); printarg_ud(ud1);
fputs(" ud2=", vm_out); printarg_ud(ud2);
}
#endif
sp += 3;
{
#line 1067 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1066
f = FLAG(ud1.hi==ud2.hi ? ud1.lo<ud2.lo : ud1.hi<ud2.hi);
#line 1066
#else
#line 1066
f = FLAG(ud1<ud2);
#line 1066
#endif
#line 1066
#line 5396 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_u_less_than)
NEXT_P2;
}

LABEL(d_u_greater_than) /* du> ( ud1 ud2 -- f ) */
/*  */
NAME("du>")
{
DEF_CA
UDCell ud1;
UDCell ud2;
Bool f;
NEXT_P0;
vm_twoCell2ud((Cell)sp[3], (Cell)sp[2], ud1)
vm_twoCell2ud((Cell)sp[1], (Cell)spTOS, ud2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud1=", vm_out); printarg_ud(ud1);
fputs(" ud2=", vm_out); printarg_ud(ud2);
}
#endif
sp += 3;
{
#line 1067 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1066
f = FLAG(ud1.hi==ud2.hi ? ud1.lo>ud2.lo : ud1.hi>ud2.hi);
#line 1066
#else
#line 1066
f = FLAG(ud1>ud2);
#line 1066
#endif
#line 1066
#line 5441 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_u_greater_than)
NEXT_P2;
}

LABEL(d_u_less_or_equal) /* du<= ( ud1 ud2 -- f ) */
/*  */
NAME("du<=")
{
DEF_CA
UDCell ud1;
UDCell ud2;
Bool f;
NEXT_P0;
vm_twoCell2ud((Cell)sp[3], (Cell)sp[2], ud1)
vm_twoCell2ud((Cell)sp[1], (Cell)spTOS, ud2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud1=", vm_out); printarg_ud(ud1);
fputs(" ud2=", vm_out); printarg_ud(ud2);
}
#endif
sp += 3;
{
#line 1067 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1066
f = FLAG(ud1.hi==ud2.hi ? ud1.lo<=ud2.lo : ud1.hi<=ud2.hi);
#line 1066
#else
#line 1066
f = FLAG(ud1<=ud2);
#line 1066
#endif
#line 1066
#line 5486 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_u_less_or_equal)
NEXT_P2;
}

LABEL(d_u_greater_or_equal) /* du>= ( ud1 ud2 -- f ) */
/*  */
NAME("du>=")
{
DEF_CA
UDCell ud1;
UDCell ud2;
Bool f;
NEXT_P0;
vm_twoCell2ud((Cell)sp[3], (Cell)sp[2], ud1)
vm_twoCell2ud((Cell)sp[1], (Cell)spTOS, ud2)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud1=", vm_out); printarg_ud(ud1);
fputs(" ud2=", vm_out); printarg_ud(ud2);
}
#endif
sp += 3;
{
#line 1067 "./prim"
#ifdef BUGGY_LONG_LONG
#line 1066
f = FLAG(ud1.hi==ud2.hi ? ud1.lo>=ud2.lo : ud1.hi>=ud2.hi);
#line 1066
#else
#line 1066
f = FLAG(ud1>=ud2);
#line 1066
#endif
#line 1066
#line 5531 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(d_u_greater_or_equal)
NEXT_P2;
}

GROUPADD(18)
#endif
LABEL(within) /* within ( u1 u2 u3 -- f ) */
/* u2=<u1<u3 or: u3=<u2 and u1 is not in [u3,u2).  This works for
unsigned and signed numbers (but not a mixture).  Another way to think
about this word is to consider the numbers as a circle (wrapping
around from @code{max-u} to 0 for unsigned, and from @code{max-n} to
min-n for signed numbers); now consider the range from u2 towards
increasing numbers up to and excluding u3 (giving an empty range if
u2=u3); if u1 is in this range, @code{within} returns true. */
NAME("within")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
Bool f;
NEXT_P0;
vm_Cell2u(sp[2],u1);
vm_Cell2u(sp[1],u2);
vm_Cell2u(spTOS,u3);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
}
#endif
sp += 2;
{
#line 1079 "./prim"
f = FLAG(u1-u2 < u3-u2);
#line 5578 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(within)
NEXT_P2;
}

GROUPADD(1)
GROUP( stack, 121)
LABEL(useraddr) /* useraddr ( #u -- a_addr ) */
/*  */
NAME("useraddr")
{
DEF_CA
UCell u;
Cell * a_addr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2u(IMM_ARG(IPTOS,305397793 ),u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
INC_IP(1);
sp += -1;
{
#line 1086 "./prim"
a_addr = (Cell *)(up+u);
#line 5615 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr=", vm_out); printarg_a_(a_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_addr,spTOS);
LABEL2(useraddr)
NEXT_P2;
}

LABEL(up_store) /* up! ( a_addr -- ) */
/*  */
NAME("up!")
{
DEF_CA
Cell * a_addr;
NEXT_P0;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 1;
{
#line 1089 "./prim"
UP=up=(char *)a_addr;
#line 5647 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(up_store)
NEXT_P2;
}

LABEL(sp_fetch) /* sp@ ( -- a_addr ) */
/*  */
NAME("sp@")
{
DEF_CA
Cell * a_addr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 1095 "./prim"
a_addr = sp+1;
#line 5677 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr=", vm_out); printarg_a_(a_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_addr,spTOS);
LABEL2(sp_fetch)
NEXT_P2;
}

LABEL(sp_store) /* sp! ( a_addr -- ) */
/*  */
NAME("sp!")
{
DEF_CA
Cell * a_addr;
NEXT_P0;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 1;
{
#line 1098 "./prim"
sp = a_addr;
/* works with and without spTOS caching */
#line 5710 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(sp_store)
NEXT_P2;
}

LABEL(rp_fetch) /* rp@ ( -- a_addr ) */
/*  */
NAME("rp@")
{
DEF_CA
Cell * a_addr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 1102 "./prim"
a_addr = rp;
#line 5740 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr=", vm_out); printarg_a_(a_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_addr,spTOS);
LABEL2(rp_fetch)
NEXT_P2;
}

LABEL(rp_store) /* rp! ( a_addr -- ) */
/*  */
NAME("rp!")
{
DEF_CA
Cell * a_addr;
NEXT_P0;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 1;
{
#line 1105 "./prim"
rp = a_addr;
#line 5772 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(rp_store)
NEXT_P2;
}

GROUPADD(6)
#ifdef HAS_FLOATING
LABEL(fp_fetch) /* fp@ ( -- f_addr ) */
/*  */
NAME("fp@")
{
DEF_CA
Float * f_addr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 1110 "./prim"
f_addr = fp;
#line 5804 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f_addr=", vm_out); printarg_f_(f_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f_2Cell(f_addr,spTOS);
LABEL2(fp_fetch)
NEXT_P2;
}

LABEL(fp_store) /* fp! ( f_addr -- ) */
/*  */
NAME("fp!")
{
DEF_CA
Float * f_addr;
NEXT_P0;
vm_Cell2f_(spTOS,f_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" f_addr=", vm_out); printarg_f_(f_addr);
}
#endif
sp += 1;
{
#line 1113 "./prim"
fp = f_addr;
#line 5836 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(fp_store)
NEXT_P2;
}

GROUPADD(2)
#endif
LABEL(to_r) /* >r ( w -- R:w ) */
/*  */
NAME(">r")
{
DEF_CA
Cell w;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += 1;
rp += -1;
{
#line 1118 "./prim"
#line 5870 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,rpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(to_r)
NEXT_P2;
}

LABEL(r_from) /* r> ( R:w -- w ) */
/*  */
NAME("r>")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2w(rpTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -1;
rp += 1;
{
#line 1123 "./prim"
#line 5903 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
IF_rpTOS(rpTOS = rp[0]);
LABEL2(r_from)
NEXT_P2;
}

LABEL(rdrop) /* rdrop ( R:w -- ) */
/*  */
NAME("rdrop")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(rpTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
rp += 1;
{
#line 1128 "./prim"
#line 5934 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);
LABEL2(rdrop)
NEXT_P2;
}

LABEL(two_to_r) /* 2>r ( d -- R:d ) */
/*  */
NAME("2>r")
{
DEF_CA
DCell d;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 2;
rp += -2;
{
#line 1132 "./prim"
#line 5966 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, rp[1], rpTOS)
IF_spTOS(spTOS = sp[0]);
LABEL2(two_to_r)
NEXT_P2;
}

LABEL(two_r_from) /* 2r> ( R:d -- d ) */
/*  */
NAME("2r>")
{
DEF_CA
DCell d;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_twoCell2d((Cell)rp[1], (Cell)rpTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += -2;
rp += 2;
{
#line 1136 "./prim"
#line 5999 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, sp[1], spTOS)
IF_rpTOS(rpTOS = rp[0]);
LABEL2(two_r_from)
NEXT_P2;
}

LABEL(two_r_fetch) /* 2r@ ( R:d -- R:d d ) */
/*  */
NAME("2r@")
{
DEF_CA
DCell d;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_twoCell2d((Cell)rp[1], (Cell)rpTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += -2;
{
#line 1140 "./prim"
#line 6031 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, rp[1], rpTOS)
vm_d2twoCell(d, sp[1], spTOS)
LABEL2(two_r_fetch)
NEXT_P2;
}

LABEL(two_r_drop) /* 2rdrop ( R:d -- ) */
/*  */
NAME("2rdrop")
{
DEF_CA
DCell d;
NEXT_P0;
vm_twoCell2d((Cell)rp[1], (Cell)rpTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
rp += 2;
{
#line 1144 "./prim"
#line 6062 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);
LABEL2(two_r_drop)
NEXT_P2;
}

LABEL(over) /* over ( w1 w2 -- w1 w2 w1 ) */
/*  */
NAME("over")
{
DEF_CA
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += -1;
{
#line 1148 "./prim"
#line 6095 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(vm_w2Cell(w2,sp[1]););
vm_w2Cell(w1,spTOS);
LABEL2(over)
NEXT_P2;
}

LABEL(drop) /* drop ( w -- ) */
/*  */
NAME("drop")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += 1;
{
#line 1152 "./prim"
#line 6126 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(drop)
NEXT_P2;
}

LABEL(swap) /* swap ( w1 w2 -- w2 w1 ) */
/*  */
NAME("swap")
{
DEF_CA
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
{
#line 1156 "./prim"
#line 6158 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w2,sp[1]);
vm_w2Cell(w1,spTOS);
LABEL2(swap)
NEXT_P2;
}

LABEL(dupe) /* dup ( w -- w w ) */
/*  */
NAME("dup")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -1;
{
#line 1161 "./prim"
#line 6189 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(vm_w2Cell(w,sp[1]););
vm_w2Cell(w,spTOS);
LABEL2(dupe)
NEXT_P2;
}

LABEL(rote) /* rot ( w1 w2 w3 -- w2 w3 w1 ) */
/*  */
NAME("rot")
{
DEF_CA
Cell w1;
Cell w2;
Cell w3;
NEXT_P0;
vm_Cell2w(sp[2],w1);
vm_Cell2w(sp[1],w2);
vm_Cell2w(spTOS,w3);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputs(" w3=", vm_out); printarg_w(w3);
}
#endif
{
#line 1165 "./prim"
#line 6225 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w2,sp[2]);
vm_w2Cell(w3,sp[1]);
vm_w2Cell(w1,spTOS);
LABEL2(rote)
NEXT_P2;
}

LABEL(not_rote) /* -rot ( w1 w2 w3 -- w3 w1 w2 ) */
/*  */
NAME("-rot")
{
DEF_CA
Cell w1;
Cell w2;
Cell w3;
NEXT_P0;
vm_Cell2w(sp[2],w1);
vm_Cell2w(sp[1],w2);
vm_Cell2w(spTOS,w3);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputs(" w3=", vm_out); printarg_w(w3);
}
#endif
{
#line 1174 "./prim"
#line 6262 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w3,sp[2]);
vm_w2Cell(w1,sp[1]);
vm_w2Cell(w2,spTOS);
LABEL2(not_rote)
NEXT_P2;
}

LABEL(nip) /* nip ( w1 w2 -- w2 ) */
/*  */
NAME("nip")
{
DEF_CA
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += 1;
{
#line 1178 "./prim"
#line 6297 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w2,spTOS);
LABEL2(nip)
NEXT_P2;
}

LABEL(tuck) /* tuck ( w1 w2 -- w2 w1 w2 ) */
/*  */
NAME("tuck")
{
DEF_CA
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += -1;
{
#line 1182 "./prim"
#line 6330 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w2,sp[2]);
vm_w2Cell(w1,sp[1]);
vm_w2Cell(w2,spTOS);
LABEL2(tuck)
NEXT_P2;
}

LABEL(question_dupe) /* ?dup ( w -- w ) */
/* Actually the stack effect is: @code{( w -- 0 | w w )}.  It performs a
@code{dup} if w is nonzero. */
NAME("?dup")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 1188 "./prim"
if (w!=0) {
  IF_spTOS(*sp-- = w;)
#ifndef USE_TOS
  *--sp = w;
#endif
}
#line 6368 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(question_dupe)
NEXT_P2;
}

LABEL(pick) /* pick ( u -- w ) */
/* Actually the stack effect is @code{ x0 ... xu u -- x0 ... xu x0 }. */
NAME("pick")
{
DEF_CA
UCell u;
Cell w;
NEXT_P0;
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
{
#line 1199 "./prim"
w = sp[u+1];
#line 6398 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(pick)
NEXT_P2;
}

LABEL(two_drop) /* 2drop ( w1 w2 -- ) */
/*  */
NAME("2drop")
{
DEF_CA
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += 2;
{
#line 1204 "./prim"
#line 6432 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(two_drop)
NEXT_P2;
}

LABEL(two_dupe) /* 2dup ( w1 w2 -- w1 w2 w1 w2 ) */
/*  */
NAME("2dup")
{
DEF_CA
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2w(sp[1],w1);
vm_Cell2w(spTOS,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
sp += -2;
{
#line 1208 "./prim"
#line 6465 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(vm_w2Cell(w2,sp[2]););
vm_w2Cell(w1,sp[1]);
vm_w2Cell(w2,spTOS);
LABEL2(two_dupe)
NEXT_P2;
}

LABEL(two_over) /* 2over ( w1 w2 w3 w4 -- w1 w2 w3 w4 w1 w2 ) */
/*  */
NAME("2over")
{
DEF_CA
Cell w1;
Cell w2;
Cell w3;
Cell w4;
NEXT_P0;
vm_Cell2w(sp[3],w1);
vm_Cell2w(sp[2],w2);
vm_Cell2w(sp[1],w3);
vm_Cell2w(spTOS,w4);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputs(" w3=", vm_out); printarg_w(w3);
fputs(" w4=", vm_out); printarg_w(w4);
}
#endif
sp += -2;
{
#line 1212 "./prim"
#line 6506 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(vm_w2Cell(w4,sp[2]););
vm_w2Cell(w1,sp[1]);
vm_w2Cell(w2,spTOS);
LABEL2(two_over)
NEXT_P2;
}

LABEL(two_swap) /* 2swap ( w1 w2 w3 w4 -- w3 w4 w1 w2 ) */
/*  */
NAME("2swap")
{
DEF_CA
Cell w1;
Cell w2;
Cell w3;
Cell w4;
NEXT_P0;
vm_Cell2w(sp[3],w1);
vm_Cell2w(sp[2],w2);
vm_Cell2w(sp[1],w3);
vm_Cell2w(spTOS,w4);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputs(" w3=", vm_out); printarg_w(w3);
fputs(" w4=", vm_out); printarg_w(w4);
}
#endif
{
#line 1216 "./prim"
#line 6546 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w3,sp[3]);
vm_w2Cell(w4,sp[2]);
vm_w2Cell(w1,sp[1]);
vm_w2Cell(w2,spTOS);
LABEL2(two_swap)
NEXT_P2;
}

LABEL(two_rote) /* 2rot ( w1 w2 w3 w4 w5 w6 -- w3 w4 w5 w6 w1 w2 ) */
/*  */
NAME("2rot")
{
DEF_CA
Cell w1;
Cell w2;
Cell w3;
Cell w4;
Cell w5;
Cell w6;
NEXT_P0;
vm_Cell2w(sp[5],w1);
vm_Cell2w(sp[4],w2);
vm_Cell2w(sp[3],w3);
vm_Cell2w(sp[2],w4);
vm_Cell2w(sp[1],w5);
vm_Cell2w(spTOS,w6);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputs(" w3=", vm_out); printarg_w(w3);
fputs(" w4=", vm_out); printarg_w(w4);
fputs(" w5=", vm_out); printarg_w(w5);
fputs(" w6=", vm_out); printarg_w(w6);
}
#endif
{
#line 1220 "./prim"
#line 6593 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w3,sp[5]);
vm_w2Cell(w4,sp[4]);
vm_w2Cell(w5,sp[3]);
vm_w2Cell(w6,sp[2]);
vm_w2Cell(w1,sp[1]);
vm_w2Cell(w2,spTOS);
LABEL2(two_rote)
NEXT_P2;
}

LABEL(two_nip) /* 2nip ( w1 w2 w3 w4 -- w3 w4 ) */
/*  */
NAME("2nip")
{
DEF_CA
Cell w1;
Cell w2;
Cell w3;
Cell w4;
NEXT_P0;
vm_Cell2w(sp[3],w1);
vm_Cell2w(sp[2],w2);
vm_Cell2w(sp[1],w3);
vm_Cell2w(spTOS,w4);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputs(" w3=", vm_out); printarg_w(w3);
fputs(" w4=", vm_out); printarg_w(w4);
}
#endif
sp += 2;
{
#line 1224 "./prim"
#line 6637 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w3,sp[1]);
vm_w2Cell(w4,spTOS);
LABEL2(two_nip)
NEXT_P2;
}

LABEL(two_tuck) /* 2tuck ( w1 w2 w3 w4 -- w3 w4 w1 w2 w3 w4 ) */
/*  */
NAME("2tuck")
{
DEF_CA
Cell w1;
Cell w2;
Cell w3;
Cell w4;
NEXT_P0;
vm_Cell2w(sp[3],w1);
vm_Cell2w(sp[2],w2);
vm_Cell2w(sp[1],w3);
vm_Cell2w(spTOS,w4);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputs(" w3=", vm_out); printarg_w(w3);
fputs(" w4=", vm_out); printarg_w(w4);
}
#endif
sp += -2;
{
#line 1228 "./prim"
#line 6677 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w3,sp[5]);
vm_w2Cell(w4,sp[4]);
vm_w2Cell(w1,sp[3]);
vm_w2Cell(w2,sp[2]);
vm_w2Cell(w3,sp[1]);
vm_w2Cell(w4,spTOS);
LABEL2(two_tuck)
NEXT_P2;
}

GROUPADD(24)
GROUP( memory, 153)
LABEL(fetch) /* @ ( a_addr -- w ) */
/* @i{w} is the cell stored at @i{a_addr}. */
NAME("@")
{
DEF_CA
Cell * a_addr;
Cell w;
NEXT_P0;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
{
#line 1237 "./prim"
w = *a_addr;
#line 6715 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(fetch)
NEXT_P2;
}

LABEL(lit_fetch) /* lit@ ( #a_addr -- w ) */
/*  */
NAME("lit@")
{
DEF_CA
Cell * a_addr;
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397794 ),a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(1);
sp += -1;
{
#line 1242 "./prim"
w = *a_addr;
#line 6750 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(lit_fetch)
NEXT_P2;
}

LABEL(store) /* ! ( w a_addr -- ) */
/* Store @i{w} into the cell at @i{a-addr}. */
NAME("!")
{
DEF_CA
Cell w;
Cell * a_addr;
NEXT_P0;
vm_Cell2w(sp[1],w);
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 2;
{
#line 1246 "./prim"
*a_addr = w;
#line 6785 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(store)
NEXT_P2;
}

LABEL(plus_store) /* +! ( n a_addr -- ) */
/* Add @i{n} to the cell at @i{a-addr}. */
NAME("+!")
{
DEF_CA
Cell n;
Cell * a_addr;
NEXT_P0;
vm_Cell2n(sp[1],n);
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 2;
{
#line 1250 "./prim"
*a_addr += n;
#line 6819 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(plus_store)
NEXT_P2;
}

LABEL(c_fetch) /* c@ ( c_addr -- c ) */
/* @i{c} is the char stored at @i{c_addr}. */
NAME("c@")
{
DEF_CA
Char * c_addr;
Char c;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
{
#line 1256 "./prim"
c = *c_addr;
#line 6850 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c=", vm_out); printarg_c(c);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c2Cell(c,spTOS);
LABEL2(c_fetch)
NEXT_P2;
}

LABEL(c_store) /* c! ( c c_addr -- ) */
/* Store @i{c} into the char at @i{c-addr}. */
NAME("c!")
{
DEF_CA
Char c;
Char * c_addr;
NEXT_P0;
vm_Cell2c(sp[1],c);
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c=", vm_out); printarg_c(c);
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 2;
{
#line 1282 "./prim"
*c_addr = c;
#line 6885 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(c_store)
NEXT_P2;
}

LABEL(two_store) /* 2! ( w1 w2 a_addr -- ) */
/* Store @i{w2} into the cell at @i{c-addr} and @i{w1} into the next cell. */
NAME("2!")
{
DEF_CA
Cell w1;
Cell w2;
Cell * a_addr;
NEXT_P0;
vm_Cell2w(sp[2],w1);
vm_Cell2w(sp[1],w2);
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 3;
{
#line 1312 "./prim"
a_addr[0] = w2;
a_addr[1] = w1;
#line 6923 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(two_store)
NEXT_P2;
}

LABEL(two_fetch) /* 2@ ( a_addr -- w1 w2 ) */
/* @i{w2} is the content of the cell stored at @i{a-addr}, @i{w1} is
the content of the next cell. */
NAME("2@")
{
DEF_CA
Cell * a_addr;
Cell w1;
Cell w2;
NEXT_P0;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += -1;
{
#line 1320 "./prim"
w2 = a_addr[0];
w1 = a_addr[1];
#line 6958 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w1,sp[1]);
vm_w2Cell(w2,spTOS);
LABEL2(two_fetch)
NEXT_P2;
}

LABEL(cell_plus) /* cell+ ( a_addr1 -- a_addr2 ) */
/* @code{1 cells +} */
NAME("cell+")
{
DEF_CA
Cell * a_addr1;
Cell * a_addr2;
NEXT_P0;
vm_Cell2a_(spTOS,a_addr1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr1=", vm_out); printarg_a_(a_addr1);
}
#endif
{
#line 1327 "./prim"
a_addr2 = a_addr1+1;
#line 6992 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr2=", vm_out); printarg_a_(a_addr2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_addr2,spTOS);
LABEL2(cell_plus)
NEXT_P2;
}

LABEL(cells) /* cells ( n1 -- n2 ) */
/*  @i{n2} is the number of address units of @i{n1} cells. */
NAME("cells")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 1333 "./prim"
n2 = n1 * sizeof(Cell);
#line 7024 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(cells)
NEXT_P2;
}

LABEL(char_plus) /* char+ ( c_addr1 -- c_addr2 ) */
/* @code{1 chars +}. */
NAME("char+")
{
DEF_CA
Char * c_addr1;
Char * c_addr2;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
}
#endif
{
#line 1344 "./prim"
c_addr2 = c_addr1 + 1;
#line 7056 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr2=", vm_out); printarg_c_(c_addr2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr2,spTOS);
LABEL2(char_plus)
NEXT_P2;
}

LABEL(paren_chars) /* (chars) ( n1 -- n2 ) */
/*  */
NAME("(chars)")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 1349 "./prim"
n2 = n1 * sizeof(Char);
#line 7088 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(paren_chars)
NEXT_P2;
}

LABEL(count) /* count ( c_addr1 -- c_addr2 u ) */
/* @i{c-addr2} is the first character and @i{u} the length of the
counted string at @i{c-addr1}. */
NAME("count")
{
DEF_CA
Char * c_addr1;
Char * c_addr2;
UCell u;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
}
#endif
sp += -1;
{
#line 1356 "./prim"
u = *c_addr1;
c_addr2 = c_addr1+1;
#line 7124 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr2=", vm_out); printarg_c_(c_addr2);
fputs(" u=", vm_out); printarg_u(u);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr2,sp[1]);
vm_u2Cell(u,spTOS);
LABEL2(count)
NEXT_P2;
}

GROUPADD(13)
GROUP( compiler, 166)
GROUPADD(0)
#ifdef HAS_F83HEADERSTRING
LABEL(paren_f83find) /* (f83find) ( c_addr u f83name1 -- f83name2 ) */
/*  */
NAME("(f83find)")
{
DEF_CA
Char * c_addr;
UCell u;
struct F83Name * f83name1;
struct F83Name * f83name2;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2f83name(spTOS,f83name1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" f83name1=", vm_out); printarg_f83name(f83name1);
}
#endif
sp += 2;
{
#line 1366 "./prim"
for (; f83name1 != NULL; f83name1 = (struct F83Name *)(f83name1->next))
  if ((UCell)F83NAME_COUNT(f83name1)==u &&
      memcasecmp(c_addr, f83name1->name, u)== 0 /* or inline? */)
    break;
f83name2=f83name1;
#line 7173 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f83name2=", vm_out); printarg_f83name(f83name2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f83name2Cell(f83name2,spTOS);
LABEL2(paren_f83find)
NEXT_P2;
}

GROUPADD(1)
#else /* 167 */
LABEL(paren_listlfind) /* (listlfind) ( c_addr u longname1 -- longname2 ) */
/*  */
NAME("(listlfind)")
{
DEF_CA
Char * c_addr;
UCell u;
struct Longname * longname1;
struct Longname * longname2;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2longname(spTOS,longname1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" longname1=", vm_out); printarg_longname(longname1);
}
#endif
sp += 2;
{
#line 1391 "./prim"
longname2=listlfind(c_addr, u, longname1);
#line 7214 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" longname2=", vm_out); printarg_longname(longname2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_longname2Cell(longname2,spTOS);
LABEL2(paren_listlfind)
NEXT_P2;
}

GROUPADD(1)
#ifdef HAS_HASH
LABEL(paren_hashlfind) /* (hashlfind) ( c_addr u a_addr -- longname2 ) */
/*  */
NAME("(hashlfind)")
{
DEF_CA
Char * c_addr;
UCell u;
Cell * a_addr;
struct Longname * longname2;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 2;
{
#line 1404 "./prim"
longname2 = hashlfind(c_addr, u, a_addr);
#line 7255 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" longname2=", vm_out); printarg_longname(longname2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_longname2Cell(longname2,spTOS);
LABEL2(paren_hashlfind)
NEXT_P2;
}

LABEL(paren_tablelfind) /* (tablelfind) ( c_addr u a_addr -- longname2 ) */
/* A case-sensitive variant of @code{(hashfind)} */
NAME("(tablelfind)")
{
DEF_CA
Char * c_addr;
UCell u;
Cell * a_addr;
struct Longname * longname2;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 2;
{
#line 1415 "./prim"
longname2 = tablelfind(c_addr, u, a_addr);
#line 7294 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" longname2=", vm_out); printarg_longname(longname2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_longname2Cell(longname2,spTOS);
LABEL2(paren_tablelfind)
NEXT_P2;
}

LABEL(paren_hashkey1) /* (hashkey1) ( c_addr u ubits -- ukey ) */
/* ukey is the hash key for the string c_addr u fitting in ubits bits */
NAME("(hashkey1)")
{
DEF_CA
Char * c_addr;
UCell u;
UCell ubits;
UCell ukey;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2u(spTOS,ubits);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" ubits=", vm_out); printarg_u(ubits);
}
#endif
sp += 2;
{
#line 1432 "./prim"
ukey = hashkey1(c_addr, u, ubits);
#line 7333 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" ukey=", vm_out); printarg_u(ukey);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(ukey,spTOS);
LABEL2(paren_hashkey1)
NEXT_P2;
}

GROUPADD(3)
#endif
GROUPADD(0)
#endif
LABEL(paren_parse_white) /* (parse-white) ( c_addr1 u1 -- c_addr2 u2 ) */
/*  */
NAME("(parse-white)")
{
DEF_CA
Char * c_addr1;
UCell u1;
Char * c_addr2;
UCell u2;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr1);
vm_Cell2u(spTOS,u1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
fputs(" u1=", vm_out); printarg_u(u1);
}
#endif
{
#line 1451 "./prim"
struct Cellpair r=parse_white(c_addr1, u1);
c_addr2 = (Char *)(r.n1);
u2 = r.n2;
#line 7375 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr2=", vm_out); printarg_c_(c_addr2);
fputs(" u2=", vm_out); printarg_u(u2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr2,sp[1]);
vm_u2Cell(u2,spTOS);
LABEL2(paren_parse_white)
NEXT_P2;
}

LABEL(aligned) /* aligned ( c_addr -- a_addr ) */
/*  @i{a-addr} is the first aligned address greater than or equal to @i{c-addr}. */
NAME("aligned")
{
DEF_CA
Char * c_addr;
Cell * a_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
{
#line 1462 "./prim"
a_addr = (Cell *)((((Cell)c_addr)+(sizeof(Cell)-1))&(-sizeof(Cell)));
#line 7409 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr=", vm_out); printarg_a_(a_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_addr,spTOS);
LABEL2(aligned)
NEXT_P2;
}

LABEL(f_aligned) /* faligned ( c_addr -- f_addr ) */
/*  @i{f-addr} is the first float-aligned address greater than or equal to @i{c-addr}. */
NAME("faligned")
{
DEF_CA
Char * c_addr;
Float * f_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
{
#line 1468 "./prim"
f_addr = (Float *)((((Cell)c_addr)+(sizeof(Float)-1))&(-sizeof(Float)));
#line 7441 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f_addr=", vm_out); printarg_f_(f_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f_2Cell(f_addr,spTOS);
LABEL2(f_aligned)
NEXT_P2;
}

LABEL(threading_method) /* threading-method ( -- n ) */
/* 0 if the engine is direct threaded. Note that this may change during
the lifetime of an image. */
NAME("threading-method")
{
DEF_CA
Cell n;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 1477 "./prim"
#if defined(DOUBLY_INDIRECT)
n=2;
#else
# if defined(DIRECT_THREADED)
n=0;
# else
n=1;
# endif
#endif
#line 7481 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(threading_method)
NEXT_P2;
}

GROUPADD(4)
GROUP( hostos, 175)
LABEL(paren_key_file) /* key-file ( wfileid -- n ) */
/*  */
NAME("key-file")
{
DEF_CA
Cell wfileid;
Cell n;
NEXT_P0;
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
{
#line 1494 "./prim"
#ifdef HAS_FILE
fflush(stdout);
n = key((FILE*)wfileid);
#else
n = key(stdin);
#endif
#line 7520 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(paren_key_file)
NEXT_P2;
}

LABEL(key_q_file) /* key?-file ( wfileid -- n ) */
/*  */
NAME("key?-file")
{
DEF_CA
Cell wfileid;
Cell n;
NEXT_P0;
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
{
#line 1502 "./prim"
#ifdef HAS_FILE
fflush(stdout);
n = key_query((FILE*)wfileid);
#else
n = key_query(stdin);
#endif
#line 7557 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,spTOS);
LABEL2(key_q_file)
NEXT_P2;
}

GROUPADD(2)
#ifdef HAS_OS
LABEL(stdin) /* stdin ( -- wfileid ) */
/*  */
NAME("stdin")
{
DEF_CA
Cell wfileid;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 1512 "./prim"
wfileid = (Cell)stdin;
#line 7590 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wfileid=", vm_out); printarg_w(wfileid);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wfileid,spTOS);
LABEL2(stdin)
NEXT_P2;
}

LABEL(stdout) /* stdout ( -- wfileid ) */
/*  */
NAME("stdout")
{
DEF_CA
Cell wfileid;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 1515 "./prim"
wfileid = (Cell)stdout;
#line 7621 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wfileid=", vm_out); printarg_w(wfileid);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wfileid,spTOS);
LABEL2(stdout)
NEXT_P2;
}

LABEL(stderr) /* stderr ( -- wfileid ) */
/*  */
NAME("stderr")
{
DEF_CA
Cell wfileid;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 1518 "./prim"
wfileid = (Cell)stderr;
#line 7652 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wfileid=", vm_out); printarg_w(wfileid);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wfileid,spTOS);
LABEL2(stderr)
NEXT_P2;
}

LABEL(form) /* form ( -- urows ucols ) */
/* The number of lines and columns in the terminal. These numbers may change
with the window size. */
NAME("form")
{
DEF_CA
UCell urows;
UCell ucols;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -2;
{
#line 1523 "./prim"
/* we could block SIGWINCH here to get a consistent size, but I don't
 think this is necessary or always beneficial */
urows=rows;
ucols=cols;
#line 7688 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" urows=", vm_out); printarg_u(urows);
fputs(" ucols=", vm_out); printarg_u(ucols);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(urows,sp[1]);
vm_u2Cell(ucols,spTOS);
LABEL2(form)
NEXT_P2;
}

LABEL(flush_icache) /* flush-icache ( c_addr u -- ) */
/* Make sure that the instruction cache of the processor (if there is
one) does not contain stale data at @i{c-addr} and @i{u} bytes
afterwards. @code{END-CODE} performs a @code{flush-icache}
automatically. Caveat: @code{flush-icache} might not work on your
installation; this is usually the case if direct threading is not
supported on your machine (take a look at your @file{machine.h}) and
your machine has a separate instruction cache. In such cases,
@code{flush-icache} does nothing instead of flushing the instruction
cache. */
NAME("flush-icache")
{
DEF_CA
Char * c_addr;
UCell u;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 2;
{
#line 1538 "./prim"
FLUSH_ICACHE(c_addr,u);
#line 7733 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(flush_icache)
NEXT_P2;
}

LABEL(paren_bye) /* (bye) ( n -- ) */
/*  */
NAME("(bye)")
{
DEF_CA
Cell n;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += 1;
{
#line 1541 "./prim"
SUPER_END;
return (Label *)n;
#line 7765 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(paren_bye)
NEXT_P2;
}

LABEL(paren_system) /* (system) ( c_addr u -- wretval wior ) */
/*  */
NAME("(system)")
{
DEF_CA
Char * c_addr;
UCell u;
Cell wretval;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
{
#line 1545 "./prim"
#ifndef MSDOS
int old_tp=terminal_prepped;
deprep_terminal();
#endif
wretval=system(cstr(c_addr,u,1)); /* ~ expansion on first part of string? */
wior = IOR(wretval==-1 || (wretval==127 && errno != 0));
#ifndef MSDOS
if (old_tp)
  prep_terminal();
#endif
#line 7809 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wretval=", vm_out); printarg_w(wretval);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wretval,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(paren_system)
NEXT_P2;
}

LABEL(getenv) /* getenv ( c_addr1 u1 -- c_addr2 u2 ) */
/* The string @i{c-addr1 u1} specifies an environment variable. The string @i{c-addr2 u2}
is the host operating system's expansion of that environment variable. If the
environment variable does not exist, @i{c-addr2 u2} specifies a string 0 characters
in length. */
NAME("getenv")
{
DEF_CA
Char * c_addr1;
UCell u1;
Char * c_addr2;
UCell u2;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr1);
vm_Cell2u(spTOS,u1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
fputs(" u1=", vm_out); printarg_u(u1);
}
#endif
{
#line 1561 "./prim"
/* close ' to keep fontify happy */
c_addr2 = getenv(cstr(c_addr1,u1,1));
u2 = (c_addr2 == NULL ? 0 : strlen(c_addr2));
#line 7852 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr2=", vm_out); printarg_c_(c_addr2);
fputs(" u2=", vm_out); printarg_u(u2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr2,sp[1]);
vm_u2Cell(u2,spTOS);
LABEL2(getenv)
NEXT_P2;
}

LABEL(open_pipe) /* open-pipe ( c_addr u wfam -- wfileid wior ) */
/*  */
NAME("open-pipe")
{
DEF_CA
Char * c_addr;
UCell u;
Cell wfam;
Cell wfileid;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2w(spTOS,wfam);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" wfam=", vm_out); printarg_w(wfam);
}
#endif
sp += 1;
{
#line 1566 "./prim"
wfileid=(Cell)popen(cstr(c_addr,u,1),pfileattr[wfam]); /* ~ expansion of 1st arg? */
wior = IOR(wfileid==0); /* !! the man page says that errno is not set reliably */
#line 7895 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wfileid=", vm_out); printarg_w(wfileid);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wfileid,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(open_pipe)
NEXT_P2;
}

LABEL(close_pipe) /* close-pipe ( wfileid -- wretval wior ) */
/*  */
NAME("close-pipe")
{
DEF_CA
Cell wfileid;
Cell wretval;
Cell wior;
NEXT_P0;
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += -1;
{
#line 1570 "./prim"
wretval = pclose((FILE *)wfileid);
wior = IOR(wretval==-1);
#line 7932 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wretval=", vm_out); printarg_w(wretval);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wretval,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(close_pipe)
NEXT_P2;
}

LABEL(time_and_date) /* time&date ( -- nsec nmin nhour nday nmonth nyear ) */
/* Report the current time of day. Seconds, minutes and hours are numbered from 0.
Months are numbered from 1. */
NAME("time&date")
{
DEF_CA
Cell nsec;
Cell nmin;
Cell nhour;
Cell nday;
Cell nmonth;
Cell nyear;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -6;
{
#line 1576 "./prim"
#if 1
time_t now;
struct tm *ltime;
time(&now);
ltime=localtime(&now);
#else
struct timeval time1;
struct timezone zone1;
struct tm *ltime;
gettimeofday(&time1,&zone1);
/* !! Single Unix specification: 
   If tzp is not a null pointer, the behaviour is unspecified. */
ltime=localtime((time_t *)&time1.tv_sec);
#endif
nyear =ltime->tm_year+1900;
nmonth=ltime->tm_mon+1;
nday  =ltime->tm_mday;
nhour =ltime->tm_hour;
nmin  =ltime->tm_min;
nsec  =ltime->tm_sec;
#line 7990 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" nsec=", vm_out); printarg_n(nsec);
fputs(" nmin=", vm_out); printarg_n(nmin);
fputs(" nhour=", vm_out); printarg_n(nhour);
fputs(" nday=", vm_out); printarg_n(nday);
fputs(" nmonth=", vm_out); printarg_n(nmonth);
fputs(" nyear=", vm_out); printarg_n(nyear);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(nsec,sp[5]);
vm_n2Cell(nmin,sp[4]);
vm_n2Cell(nhour,sp[3]);
vm_n2Cell(nday,sp[2]);
vm_n2Cell(nmonth,sp[1]);
vm_n2Cell(nyear,spTOS);
LABEL2(time_and_date)
NEXT_P2;
}

LABEL(ms) /* ms ( n -- ) */
/* Wait at least @i{n} milli-second. */
NAME("ms")
{
DEF_CA
Cell n;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += 1;
{
#line 1599 "./prim"
struct timeval timeout;
timeout.tv_sec=n/1000;
timeout.tv_usec=1000*(n%1000);
(void)select(0,0,0,0,&timeout);
#line 8035 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(ms)
NEXT_P2;
}

LABEL(allocate) /* allocate ( u -- a_addr wior ) */
/* Allocate @i{u} address units of contiguous data space. The initial
contents of the data space is undefined. If the allocation is successful,
@i{a-addr} is the start address of the allocated region and @i{wior}
is 0. If the allocation fails, @i{a-addr} is undefined and @i{wior}
is a non-zero I/O result code. */
NAME("allocate")
{
DEF_CA
UCell u;
Cell * a_addr;
Cell wior;
NEXT_P0;
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += -1;
{
#line 1610 "./prim"
a_addr = (Cell *)malloc(u?u:1);
wior = IOR(a_addr==NULL);
#line 8073 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr=", vm_out); printarg_a_(a_addr);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_addr,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(allocate)
NEXT_P2;
}

LABEL(free) /* free ( a_addr -- wior ) */
/* Return the region of data space starting at @i{a-addr} to the system.
The region must originally have been obtained using @code{allocate} or
@code{resize}. If the operational is successful, @i{wior} is 0.
If the operation fails, @i{wior} is a non-zero I/O result code. */
NAME("free")
{
DEF_CA
Cell * a_addr;
Cell wior;
NEXT_P0;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
{
#line 1618 "./prim"
free(a_addr);
wior = 0;
#line 8111 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(free)
NEXT_P2;
}

LABEL(resize) /* resize ( a_addr1 u -- a_addr2 wior ) */
/* Change the size of the allocated area at @i{a-addr1} to @i{u}
address units, possibly moving the contents to a different
area. @i{a-addr2} is the address of the resulting area.
If the operation is successful, @i{wior} is 0.
If the operation fails, @i{wior} is a non-zero
I/O result code. If @i{a-addr1} is 0, Gforth's (but not the Standard)
@code{resize} @code{allocate}s @i{u} address units. */
NAME("resize")
{
DEF_CA
Cell * a_addr1;
UCell u;
Cell * a_addr2;
Cell wior;
NEXT_P0;
vm_Cell2a_(sp[1],a_addr1);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr1=", vm_out); printarg_a_(a_addr1);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
{
#line 1629 "./prim"
/* the following check is not necessary on most OSs, but it is needed
   on SunOS 4.1.2. */
/* close ' to keep fontify happy */
if (a_addr1==NULL)
  a_addr2 = (Cell *)malloc(u);
else
  a_addr2 = (Cell *)realloc(a_addr1, u);
wior = IOR(a_addr2==NULL);	/* !! Define a return code */
#line 8160 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr2=", vm_out); printarg_a_(a_addr2);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_addr2,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(resize)
NEXT_P2;
}

LABEL(strerror) /* strerror ( n -- c_addr u ) */
/*  */
NAME("strerror")
{
DEF_CA
Cell n;
Char * c_addr;
UCell u;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += -1;
{
#line 1639 "./prim"
c_addr = strerror(n);
u = strlen(c_addr);
#line 8197 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr,sp[1]);
vm_u2Cell(u,spTOS);
LABEL2(strerror)
NEXT_P2;
}

LABEL(strsignal) /* strsignal ( n -- c_addr u ) */
/*  */
NAME("strsignal")
{
DEF_CA
Cell n;
Char * c_addr;
UCell u;
NEXT_P0;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += -1;
{
#line 1643 "./prim"
c_addr = (Address)strsignal(n);
u = strlen(c_addr);
#line 8234 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr,sp[1]);
vm_u2Cell(u,spTOS);
LABEL2(strsignal)
NEXT_P2;
}

LABEL(call_c) /* call-c ( w -- ) */
/* Call the C function pointed to by @i{w}. The C function has to
access the stack itself. The stack pointers are exported in the global
variables @code{SP} and @code{FP}. */
NAME("call-c")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += 1;
{
#line 1650 "./prim"
/* This is a first attempt at support for calls to C. This may change in
   the future */
IF_fpTOS(fp[0]=fpTOS);
FP=fp;
SP=sp;
((void (*)())w)();
sp=SP;
fp=FP;
IF_spTOS(spTOS=sp[0]);
IF_fpTOS(fpTOS=fp[0]);
#line 8279 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(call_c)
NEXT_P2;
}

GROUPADD(18)
#endif
GROUPADD(0)
#ifdef HAS_FILE
LABEL(close_file) /* close-file ( wfileid -- wior ) */
/*  */
NAME("close-file")
{
DEF_CA
Cell wfileid;
Cell wior;
NEXT_P0;
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
{
#line 1665 "./prim"
wior = IOR(fclose((FILE *)wfileid)==EOF);
#line 8314 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(close_file)
NEXT_P2;
}

LABEL(open_file) /* open-file ( c_addr u wfam -- wfileid wior ) */
/*  */
NAME("open-file")
{
DEF_CA
Char * c_addr;
UCell u;
Cell wfam;
Cell wfileid;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2w(spTOS,wfam);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" wfam=", vm_out); printarg_w(wfam);
}
#endif
sp += 1;
{
#line 1668 "./prim"
wfileid = (Cell)fopen(tilde_cstr(c_addr, u, 1), fileattr[wfam]);
wior =  IOR(wfileid == 0);
#line 8355 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wfileid=", vm_out); printarg_w(wfileid);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wfileid,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(open_file)
NEXT_P2;
}

LABEL(create_file) /* create-file ( c_addr u wfam -- wfileid wior ) */
/*  */
NAME("create-file")
{
DEF_CA
Char * c_addr;
UCell u;
Cell wfam;
Cell wfileid;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u);
vm_Cell2w(spTOS,wfam);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputs(" wfam=", vm_out); printarg_w(wfam);
}
#endif
sp += 1;
{
#line 1672 "./prim"
Cell	fd;
fd = open(tilde_cstr(c_addr, u, 1), O_CREAT|O_TRUNC|ufileattr[wfam], 0666);
if (fd != -1) {
  wfileid = (Cell)fdopen(fd, fileattr[wfam]);
  wior = IOR(wfileid == 0);
} else {
  wfileid = 0;
  wior = IOR(1);
}
#line 8405 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wfileid=", vm_out); printarg_w(wfileid);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wfileid,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(create_file)
NEXT_P2;
}

LABEL(delete_file) /* delete-file ( c_addr u -- wior ) */
/*  */
NAME("delete-file")
{
DEF_CA
Char * c_addr;
UCell u;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 1;
{
#line 1683 "./prim"
wior = IOR(unlink(tilde_cstr(c_addr, u, 1))==-1);
#line 8443 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(delete_file)
NEXT_P2;
}

LABEL(rename_file) /* rename-file ( c_addr1 u1 c_addr2 u2 -- wior ) */
/* Rename file @i{c_addr1 u1} to new name @i{c_addr2 u2} */
NAME("rename-file")
{
DEF_CA
Char * c_addr1;
UCell u1;
Char * c_addr2;
UCell u2;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[3],c_addr1);
vm_Cell2u(sp[2],u1);
vm_Cell2c_(sp[1],c_addr2);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" c_addr2=", vm_out); printarg_c_(c_addr2);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 3;
{
#line 1687 "./prim"
wior = rename_file(c_addr1, u1, c_addr2, u2);
#line 8485 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(rename_file)
NEXT_P2;
}

LABEL(file_position) /* file-position ( wfileid -- ud wior ) */
/*  */
NAME("file-position")
{
DEF_CA
Cell wfileid;
UDCell ud;
Cell wior;
NEXT_P0;
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += -2;
{
#line 1690 "./prim"
/* !! use tell and lseek? */
ud = OFF2UD(ftello((FILE *)wfileid));
wior = IOR(UD2OFF(ud)==-1);
#line 8521 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" ud=", vm_out); printarg_ud(ud);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_ud2twoCell(ud, sp[2], sp[1])
vm_w2Cell(wior,spTOS);
LABEL2(file_position)
NEXT_P2;
}

LABEL(reposition_file) /* reposition-file ( ud wfileid -- wior ) */
/*  */
NAME("reposition-file")
{
DEF_CA
UDCell ud;
Cell wfileid;
Cell wior;
NEXT_P0;
vm_twoCell2ud((Cell)sp[2], (Cell)sp[1], ud)
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud=", vm_out); printarg_ud(ud);
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += 2;
{
#line 1695 "./prim"
wior = IOR(fseeko((FILE *)wfileid, UD2OFF(ud), SEEK_SET)==-1);
#line 8559 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(reposition_file)
NEXT_P2;
}

LABEL(file_size) /* file-size ( wfileid -- ud wior ) */
/*  */
NAME("file-size")
{
DEF_CA
Cell wfileid;
UDCell ud;
Cell wior;
NEXT_P0;
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += -2;
{
#line 1698 "./prim"
struct stat buf;
wior = IOR(fstat(fileno((FILE *)wfileid), &buf)==-1);
ud = OFF2UD(buf.st_size);
#line 8595 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" ud=", vm_out); printarg_ud(ud);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_ud2twoCell(ud, sp[2], sp[1])
vm_w2Cell(wior,spTOS);
LABEL2(file_size)
NEXT_P2;
}

LABEL(resize_file) /* resize-file ( ud wfileid -- wior ) */
/*  */
NAME("resize-file")
{
DEF_CA
UDCell ud;
Cell wfileid;
Cell wior;
NEXT_P0;
vm_twoCell2ud((Cell)sp[2], (Cell)sp[1], ud)
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ud=", vm_out); printarg_ud(ud);
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += 2;
{
#line 1703 "./prim"
wior = IOR(ftruncate(fileno((FILE *)wfileid), UD2OFF(ud))==-1);
#line 8633 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(resize_file)
NEXT_P2;
}

LABEL(read_file) /* read-file ( c_addr u1 wfileid -- u2 wior ) */
/*  */
NAME("read-file")
{
DEF_CA
Char * c_addr;
UCell u1;
Cell wfileid;
UCell u2;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u1);
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += 1;
{
#line 1706 "./prim"
/* !! fread does not guarantee enough */
u2 = fread(c_addr, sizeof(Char), u1, (FILE *)wfileid);
wior = FILEIO(u2<u1 && ferror((FILE *)wfileid));
/* !! is the value of ferror errno-compatible? */
if (wior)
  clearerr((FILE *)wfileid);
#line 8678 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u2=", vm_out); printarg_u(u2);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u2,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(read_file)
NEXT_P2;
}

LABEL(paren_read_line) /* (read-line) ( c_addr u1 wfileid -- u2 flag u3 wior ) */
/*  */
NAME("(read-line)")
{
DEF_CA
Char * c_addr;
UCell u1;
Cell wfileid;
UCell u2;
Bool flag;
UCell u3;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u1);
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += -1;
{
#line 1714 "./prim"
struct Cellquad r = read_line(c_addr, u1, wfileid);
u2   = r.n1;
flag = r.n2;
u3   = r.n3;
wior = r.n4;
#line 8726 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u2=", vm_out); printarg_u(u2);
fputs(" flag=", vm_out); printarg_f(flag);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u2,sp[3]);
vm_f2Cell(flag,sp[2]);
vm_u2Cell(u3,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(paren_read_line)
NEXT_P2;
}

GROUPADD(11)
#endif
LABEL(write_file) /* write-file ( c_addr u1 wfileid -- wior ) */
/*  */
NAME("write-file")
{
DEF_CA
Char * c_addr;
UCell u1;
Cell wfileid;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u1);
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += 2;
{
#line 1723 "./prim"
/* !! fwrite does not guarantee enough */
#ifdef HAS_FILE
{
  UCell u2 = fwrite(c_addr, sizeof(Char), u1, (FILE *)wfileid);
  wior = FILEIO(u2<u1 && ferror((FILE *)wfileid));
  if (wior)
    clearerr((FILE *)wfileid);
}
#else
TYPE(c_addr, u1);
#endif
#line 8783 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(write_file)
NEXT_P2;
}

LABEL(emit_file) /* emit-file ( c wfileid -- wior ) */
/*  */
NAME("emit-file")
{
DEF_CA
Char c;
Cell wfileid;
Cell wior;
NEXT_P0;
vm_Cell2c(sp[1],c);
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c=", vm_out); printarg_c(c);
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
sp += 1;
{
#line 1736 "./prim"
#ifdef HAS_FILE
wior = FILEIO(putc(c, (FILE *)wfileid)==EOF);
if (wior)
  clearerr((FILE *)wfileid);
#else
PUTC(c);
#endif
#line 8825 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(emit_file)
NEXT_P2;
}

GROUPADD(2)
#ifdef HAS_FILE
LABEL(flush_file) /* flush-file ( wfileid -- wior ) */
/*  */
NAME("flush-file")
{
DEF_CA
Cell wfileid;
Cell wior;
NEXT_P0;
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
{
#line 1747 "./prim"
wior = IOR(fflush((FILE *) wfileid)==EOF);
#line 8859 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(flush_file)
NEXT_P2;
}

LABEL(file_status) /* file-status ( c_addr u -- wfam wior ) */
/*  */
NAME("file-status")
{
DEF_CA
Char * c_addr;
UCell u;
Cell wfam;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
{
#line 1750 "./prim"
struct Cellpair r = file_status(c_addr, u);
wfam = r.n1;
wior = r.n2;
#line 8897 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wfam=", vm_out); printarg_w(wfam);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wfam,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(file_status)
NEXT_P2;
}

LABEL(file_eof_query) /* file-eof? ( wfileid -- flag ) */
/*  */
NAME("file-eof?")
{
DEF_CA
Cell wfileid;
Bool flag;
NEXT_P0;
vm_Cell2w(spTOS,wfileid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wfileid=", vm_out); printarg_w(wfileid);
}
#endif
{
#line 1755 "./prim"
flag = FLAG(feof((FILE *) wfileid));
#line 8931 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" flag=", vm_out); printarg_f(flag);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(flag,spTOS);
LABEL2(file_eof_query)
NEXT_P2;
}

LABEL(open_dir) /* open-dir ( c_addr u -- wdirid wior ) */
/* Open the directory specified by @i{c-addr, u}
and return @i{dir-id} for futher access to it. */
NAME("open-dir")
{
DEF_CA
Char * c_addr;
UCell u;
Cell wdirid;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
{
#line 1760 "./prim"
wdirid = (Cell)opendir(tilde_cstr(c_addr, u, 1));
wior =  IOR(wdirid == 0);
#line 8969 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wdirid=", vm_out); printarg_w(wdirid);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wdirid,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(open_dir)
NEXT_P2;
}

LABEL(read_dir) /* read-dir ( c_addr u1 wdirid -- u2 flag wior ) */
/* Attempt to read the next entry from the directory specified
by @i{dir-id} to the buffer of length @i{u1} at address @i{c-addr}. 
If the attempt fails because there is no more entries,
@i{ior}=0, @i{flag}=0, @i{u2}=0, and the buffer is unmodified.
If the attempt to read the next entry fails because of any other reason, 
return @i{ior}<>0.
If the attempt succeeds, store file name to the buffer at @i{c-addr}
and return @i{ior}=0, @i{flag}=true and @i{u2} equal to the size of the file name.
If the length of the file name is greater than @i{u1}, 
store first @i{u1} characters from file name into the buffer and
indicate "name too long" with @i{ior}, @i{flag}=true, and @i{u2}=@i{u1}. */
NAME("read-dir")
{
DEF_CA
Char * c_addr;
UCell u1;
Cell wdirid;
UCell u2;
Bool flag;
Cell wior;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr);
vm_Cell2u(sp[1],u1);
vm_Cell2w(spTOS,wdirid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" wdirid=", vm_out); printarg_w(wdirid);
}
#endif
{
#line 1775 "./prim"
struct dirent * dent;
dent = readdir((DIR *)wdirid);
wior = 0;
flag = -1;
if(dent == NULL) {
  u2 = 0;
  flag = 0;
} else {
  u2 = strlen(dent->d_name);
  if(u2 > u1) {
    u2 = u1;
    wior = -512-ENAMETOOLONG;
  }
  memmove(c_addr, dent->d_name, u2);
}
#line 9035 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u2=", vm_out); printarg_u(u2);
fputs(" flag=", vm_out); printarg_f(flag);
fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u2,sp[2]);
vm_f2Cell(flag,sp[1]);
vm_w2Cell(wior,spTOS);
LABEL2(read_dir)
NEXT_P2;
}

LABEL(close_dir) /* close-dir ( wdirid -- wior ) */
/* Close the directory specified by @i{dir-id}. */
NAME("close-dir")
{
DEF_CA
Cell wdirid;
Cell wior;
NEXT_P0;
vm_Cell2w(spTOS,wdirid);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" wdirid=", vm_out); printarg_w(wdirid);
}
#endif
{
#line 1793 "./prim"
wior = IOR(closedir((DIR *)wdirid));
#line 9071 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" wior=", vm_out); printarg_w(wior);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(wior,spTOS);
LABEL2(close_dir)
NEXT_P2;
}

LABEL(match_file) /* filename-match ( c_addr1 u1 c_addr2 u2 -- flag ) */
/*  */
NAME("filename-match")
{
DEF_CA
Char * c_addr1;
UCell u1;
Char * c_addr2;
UCell u2;
Bool flag;
NEXT_P0;
vm_Cell2c_(sp[3],c_addr1);
vm_Cell2u(sp[2],u1);
vm_Cell2c_(sp[1],c_addr2);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" c_addr2=", vm_out); printarg_c_(c_addr2);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 3;
{
#line 1796 "./prim"
char * string = cstr(c_addr1, u1, 1);
char * pattern = cstr(c_addr2, u2, 0);
flag = FLAG(!fnmatch(pattern, string, 0));
#line 9115 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" flag=", vm_out); printarg_f(flag);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(flag,spTOS);
LABEL2(match_file)
NEXT_P2;
}

GROUPADD(7)
#endif
LABEL(newline) /* newline ( -- c_addr u ) */
/* String containing the newline sequence of the host OS */
NAME("newline")
{
DEF_CA
Char * c_addr;
UCell u;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -2;
{
#line 1804 "./prim"
char newline[] = {
#if DIRSEP=='/'
/* Unix */
'\n'
#else
/* DOS, Win, OS/2 */
'\r','\n'
#endif
};
c_addr=newline;
u=sizeof(newline);
#line 9159 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr,sp[1]);
vm_u2Cell(u,spTOS);
LABEL2(newline)
NEXT_P2;
}

GROUPADD(1)
#ifdef HAS_OS
LABEL(utime) /* utime ( -- dtime ) */
/* Report the current time in microseconds since some epoch. */
NAME("utime")
{
DEF_CA
DCell dtime;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -2;
{
#line 1823 "./prim"
struct timeval time1;
gettimeofday(&time1,NULL);
dtime = timeval2us(&time1);
#line 9196 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" dtime=", vm_out); printarg_d(dtime);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(dtime, sp[1], spTOS)
LABEL2(utime)
NEXT_P2;
}

LABEL(cputime) /* cputime ( -- duser dsystem ) */
/* duser and dsystem are the respective user- and system-level CPU
times used since the start of the Forth system (excluding child
processes), in microseconds (the granularity may be much larger,
however).  On platforms without the getrusage call, it reports elapsed
time (since some epoch) for duser and 0 for dsystem. */
NAME("cputime")
{
DEF_CA
DCell duser;
DCell dsystem;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -4;
{
#line 1833 "./prim"
#ifdef HAVE_GETRUSAGE
struct rusage usage;
getrusage(RUSAGE_SELF, &usage);
duser = timeval2us(&usage.ru_utime);
dsystem = timeval2us(&usage.ru_stime);
#else
struct timeval time1;
gettimeofday(&time1,NULL);
duser = timeval2us(&time1);
#ifndef BUGGY_LONG_LONG
dsystem = (DCell)0;
#else
dsystem=(DCell){0,0};
#endif
#endif
#line 9246 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" duser=", vm_out); printarg_d(duser);
fputs(" dsystem=", vm_out); printarg_d(dsystem);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(duser, sp[3], sp[2])
vm_d2twoCell(dsystem, sp[1], spTOS)
LABEL2(cputime)
NEXT_P2;
}

GROUPADD(2)
#endif
GROUPADD(0)
#ifdef HAS_FLOATING
GROUPADD(0)
GROUP( floating, 218)
LABEL(f_equals) /* f= ( r1 r2 -- f ) */
/*  */
NAME("f=")
{
DEF_CA
Float r1;
Float r2;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
sp += -1;
fp += 2;
{
#line 1855 "./prim"
f = FLAG(r1==r2);
#line 1854
#line 9293 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_equals)
NEXT_P2;
}

LABEL(f_not_equals) /* f<> ( r1 r2 -- f ) */
/*  */
NAME("f<>")
{
DEF_CA
Float r1;
Float r2;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
sp += -1;
fp += 2;
{
#line 1855 "./prim"
f = FLAG(r1!=r2);
#line 1854
#line 9333 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_not_equals)
NEXT_P2;
}

LABEL(f_less_than) /* f< ( r1 r2 -- f ) */
/*  */
NAME("f<")
{
DEF_CA
Float r1;
Float r2;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
sp += -1;
fp += 2;
{
#line 1855 "./prim"
f = FLAG(r1<r2);
#line 1854
#line 9373 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_less_than)
NEXT_P2;
}

LABEL(f_greater_than) /* f> ( r1 r2 -- f ) */
/*  */
NAME("f>")
{
DEF_CA
Float r1;
Float r2;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
sp += -1;
fp += 2;
{
#line 1855 "./prim"
f = FLAG(r1>r2);
#line 1854
#line 9413 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_greater_than)
NEXT_P2;
}

LABEL(f_less_or_equal) /* f<= ( r1 r2 -- f ) */
/*  */
NAME("f<=")
{
DEF_CA
Float r1;
Float r2;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
sp += -1;
fp += 2;
{
#line 1855 "./prim"
f = FLAG(r1<=r2);
#line 1854
#line 9453 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_less_or_equal)
NEXT_P2;
}

LABEL(f_greater_or_equal) /* f>= ( r1 r2 -- f ) */
/*  */
NAME("f>=")
{
DEF_CA
Float r1;
Float r2;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
sp += -1;
fp += 2;
{
#line 1855 "./prim"
f = FLAG(r1>=r2);
#line 1854
#line 9493 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_greater_or_equal)
NEXT_P2;
}

LABEL(f_zero_equals) /* f0= ( r -- f ) */
/*  */
NAME("f0=")
{
DEF_CA
Float r;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
sp += -1;
fp += 1;
{
#line 1856 "./prim"
f = FLAG(r==0.);
#line 1855
#line 9530 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_zero_equals)
NEXT_P2;
}

LABEL(f_zero_not_equals) /* f0<> ( r -- f ) */
/*  */
NAME("f0<>")
{
DEF_CA
Float r;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
sp += -1;
fp += 1;
{
#line 1856 "./prim"
f = FLAG(r!=0.);
#line 1855
#line 9567 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_zero_not_equals)
NEXT_P2;
}

LABEL(f_zero_less_than) /* f0< ( r -- f ) */
/*  */
NAME("f0<")
{
DEF_CA
Float r;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
sp += -1;
fp += 1;
{
#line 1856 "./prim"
f = FLAG(r<0.);
#line 1855
#line 9604 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_zero_less_than)
NEXT_P2;
}

LABEL(f_zero_greater_than) /* f0> ( r -- f ) */
/*  */
NAME("f0>")
{
DEF_CA
Float r;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
sp += -1;
fp += 1;
{
#line 1856 "./prim"
f = FLAG(r>0.);
#line 1855
#line 9641 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_zero_greater_than)
NEXT_P2;
}

LABEL(f_zero_less_or_equal) /* f0<= ( r -- f ) */
/*  */
NAME("f0<=")
{
DEF_CA
Float r;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
sp += -1;
fp += 1;
{
#line 1856 "./prim"
f = FLAG(r<=0.);
#line 1855
#line 9678 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_zero_less_or_equal)
NEXT_P2;
}

LABEL(f_zero_greater_or_equal) /* f0>= ( r -- f ) */
/*  */
NAME("f0>=")
{
DEF_CA
Float r;
Bool f;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
sp += -1;
fp += 1;
{
#line 1856 "./prim"
f = FLAG(r>=0.);
#line 1855
#line 9715 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_zero_greater_or_equal)
NEXT_P2;
}

LABEL(d_to_f) /* d>f ( d -- r ) */
/*  */
NAME("d>f")
{
DEF_CA
DCell d;
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 2;
fp += -1;
{
#line 1859 "./prim"
#ifdef BUGGY_LONG_LONG
extern double ldexp(double x, int exp);
if (d.hi<0) {
  DCell d2=dnegate(d);
  r = -(ldexp((Float)d2.hi,CELL_BITS) + (Float)d2.lo);
} else
  r = ldexp((Float)d.hi,CELL_BITS) + (Float)d.lo;
#else
r = d;
#endif
#line 9760 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(d_to_f)
NEXT_P2;
}

LABEL(f_to_d) /* f>d ( r -- d ) */
/*  */
NAME("f>d")
{
DEF_CA
Float r;
DCell d;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
sp += -2;
fp += 1;
{
#line 1871 "./prim"
extern DCell double2ll(Float r);
d = double2ll(r);
#line 9797 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d=", vm_out); printarg_d(d);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, sp[1], spTOS)
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_to_d)
NEXT_P2;
}

LABEL(f_store) /* f! ( r f_addr -- ) */
/* Store @i{r} into the float at address @i{f-addr}. */
NAME("f!")
{
DEF_CA
Float r;
Float * f_addr;
NEXT_P0;
vm_Float2r(fpTOS,r);
vm_Cell2f_(spTOS,f_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
fputs(" f_addr=", vm_out); printarg_f_(f_addr);
}
#endif
sp += 1;
fp += 1;
{
#line 1876 "./prim"
*f_addr = r;
#line 9834 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_store)
NEXT_P2;
}

LABEL(f_fetch) /* f@ ( f_addr -- r ) */
/* @i{r} is the float at address @i{f-addr}. */
NAME("f@")
{
DEF_CA
Float * f_addr;
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2f_(spTOS,f_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" f_addr=", vm_out); printarg_f_(f_addr);
}
#endif
sp += 1;
fp += -1;
{
#line 1880 "./prim"
r = *f_addr;
#line 9869 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(f_fetch)
NEXT_P2;
}

LABEL(d_f_fetch) /* df@ ( df_addr -- r ) */
/* Fetch the double-precision IEEE floating-point value @i{r} from the address @i{df-addr}. */
NAME("df@")
{
DEF_CA
DFloat * df_addr;
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2df_(spTOS,df_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" df_addr=", vm_out); printarg_df_(df_addr);
}
#endif
sp += 1;
fp += -1;
{
#line 1884 "./prim"
#ifdef IEEE_FP
r = *df_addr;
#else
!! df@
#endif
#line 9909 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(d_f_fetch)
NEXT_P2;
}

LABEL(d_f_store) /* df! ( r df_addr -- ) */
/* Store @i{r} as double-precision IEEE floating-point value to the
address @i{df-addr}. */
NAME("df!")
{
DEF_CA
Float r;
DFloat * df_addr;
NEXT_P0;
vm_Float2r(fpTOS,r);
vm_Cell2df_(spTOS,df_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
fputs(" df_addr=", vm_out); printarg_df_(df_addr);
}
#endif
sp += 1;
fp += 1;
{
#line 1893 "./prim"
#ifdef IEEE_FP
*df_addr = r;
#else
!! df!
#endif
#line 9951 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(d_f_store)
NEXT_P2;
}

LABEL(s_f_fetch) /* sf@ ( sf_addr -- r ) */
/* Fetch the single-precision IEEE floating-point value @i{r} from the address @i{sf-addr}. */
NAME("sf@")
{
DEF_CA
SFloat * sf_addr;
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2sf_(spTOS,sf_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" sf_addr=", vm_out); printarg_sf_(sf_addr);
}
#endif
sp += 1;
fp += -1;
{
#line 1901 "./prim"
#ifdef IEEE_FP
r = *sf_addr;
#else
!! sf@
#endif
#line 9990 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(s_f_fetch)
NEXT_P2;
}

LABEL(s_f_store) /* sf! ( r sf_addr -- ) */
/* Store @i{r} as single-precision IEEE floating-point value to the
address @i{sf-addr}. */
NAME("sf!")
{
DEF_CA
Float r;
SFloat * sf_addr;
NEXT_P0;
vm_Float2r(fpTOS,r);
vm_Cell2sf_(spTOS,sf_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
fputs(" sf_addr=", vm_out); printarg_sf_(sf_addr);
}
#endif
sp += 1;
fp += 1;
{
#line 1910 "./prim"
#ifdef IEEE_FP
*sf_addr = r;
#else
!! sf!
#endif
#line 10032 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(s_f_store)
NEXT_P2;
}

LABEL(f_plus) /* f+ ( r1 r2 -- r3 ) */
/*  */
NAME("f+")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 1917 "./prim"
r3 = r1+r2;
#line 10068 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r3,fpTOS);
LABEL2(f_plus)
NEXT_P2;
}

LABEL(f_minus) /* f- ( r1 r2 -- r3 ) */
/*  */
NAME("f-")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 1920 "./prim"
r3 = r1-r2;
#line 10104 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r3,fpTOS);
LABEL2(f_minus)
NEXT_P2;
}

LABEL(f_star) /* f* ( r1 r2 -- r3 ) */
/*  */
NAME("f*")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 1923 "./prim"
r3 = r1*r2;
#line 10140 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r3,fpTOS);
LABEL2(f_star)
NEXT_P2;
}

LABEL(f_slash) /* f/ ( r1 r2 -- r3 ) */
/*  */
NAME("f/")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 1926 "./prim"
r3 = r1/r2;
#line 10176 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r3,fpTOS);
LABEL2(f_slash)
NEXT_P2;
}

LABEL(f_star_star) /* f** ( r1 r2 -- r3 ) */
/* @i{r3} is @i{r1} raised to the @i{r2}th power. */
NAME("f**")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 1930 "./prim"
r3 = pow(r1,r2);
#line 10212 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r3,fpTOS);
LABEL2(f_star_star)
NEXT_P2;
}

LABEL(f_negate) /* fnegate ( r1 -- r2 ) */
/*  */
NAME("fnegate")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 1933 "./prim"
r2 = - r1;
#line 10244 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_negate)
NEXT_P2;
}

LABEL(f_drop) /* fdrop ( r -- ) */
/*  */
NAME("fdrop")
{
DEF_CA
Float r;
NEXT_P0;
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
fp += 1;
{
#line 1936 "./prim"
#line 10275 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_drop)
NEXT_P2;
}

LABEL(f_dupe) /* fdup ( r -- r r ) */
/*  */
NAME("fdup")
{
DEF_CA
Float r;
NEXT_P0;
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
fp += -1;
{
#line 1938 "./prim"
#line 10305 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_fpTOS(vm_r2Float(r,fp[1]););
vm_r2Float(r,fpTOS);
LABEL2(f_dupe)
NEXT_P2;
}

LABEL(f_swap) /* fswap ( r1 r2 -- r2 r1 ) */
/*  */
NAME("fswap")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
{
#line 1940 "./prim"
#line 10338 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fp[1]);
vm_r2Float(r1,fpTOS);
LABEL2(f_swap)
NEXT_P2;
}

LABEL(f_over) /* fover ( r1 r2 -- r1 r2 r1 ) */
/*  */
NAME("fover")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += -1;
{
#line 1942 "./prim"
#line 10372 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_fpTOS(vm_r2Float(r2,fp[1]););
vm_r2Float(r1,fpTOS);
LABEL2(f_over)
NEXT_P2;
}

LABEL(f_rote) /* frot ( r1 r2 r3 -- r2 r3 r1 ) */
/*  */
NAME("frot")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[2],r1);
vm_Float2r(fp[1],r2);
vm_Float2r(fpTOS,r3);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
fputs(" r3=", vm_out); printarg_r(r3);
}
#endif
{
#line 1944 "./prim"
#line 10408 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fp[2]);
vm_r2Float(r3,fp[1]);
vm_r2Float(r1,fpTOS);
LABEL2(f_rote)
NEXT_P2;
}

LABEL(f_nip) /* fnip ( r1 r2 -- r2 ) */
/*  */
NAME("fnip")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 1946 "./prim"
#line 10443 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_nip)
NEXT_P2;
}

LABEL(f_tuck) /* ftuck ( r1 r2 -- r2 r1 r2 ) */
/*  */
NAME("ftuck")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += -1;
{
#line 1948 "./prim"
#line 10476 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fp[2]);
vm_r2Float(r1,fp[1]);
vm_r2Float(r2,fpTOS);
LABEL2(f_tuck)
NEXT_P2;
}

LABEL(float_plus) /* float+ ( f_addr1 -- f_addr2 ) */
/* @code{1 floats +}. */
NAME("float+")
{
DEF_CA
Float * f_addr1;
Float * f_addr2;
NEXT_P0;
vm_Cell2f_(spTOS,f_addr1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" f_addr1=", vm_out); printarg_f_(f_addr1);
}
#endif
{
#line 1951 "./prim"
f_addr2 = f_addr1+1;
#line 10509 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f_addr2=", vm_out); printarg_f_(f_addr2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f_2Cell(f_addr2,spTOS);
LABEL2(float_plus)
NEXT_P2;
}

LABEL(floats) /* floats ( n1 -- n2 ) */
/* @i{n2} is the number of address units of @i{n1} floats. */
NAME("floats")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 1955 "./prim"
n2 = n1*sizeof(Float);
#line 10541 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(floats)
NEXT_P2;
}

LABEL(floor) /* floor ( r1 -- r2 ) */
/* Round towards the next smaller integral value, i.e., round toward negative infinity. */
NAME("floor")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 1959 "./prim"
/* !! unclear wording */
r2 = floor(r1);
#line 10574 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(floor)
NEXT_P2;
}

LABEL(f_round) /* fround ( r1 -- r2 ) */
/* Round to the nearest integral value. */
NAME("fround")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 1964 "./prim"
r2 = rint(r1);
#line 10606 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_round)
NEXT_P2;
}

LABEL(f_max) /* fmax ( r1 r2 -- r3 ) */
/*  */
NAME("fmax")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 1967 "./prim"
if (r1<r2)
  r3 = r2;
else
  r3 = r1;
#line 10645 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r3,fpTOS);
LABEL2(f_max)
NEXT_P2;
}

LABEL(f_min) /* fmin ( r1 r2 -- r3 ) */
/*  */
NAME("fmin")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 1973 "./prim"
if (r1<r2)
  r3 = r1;
else
  r3 = r2;
#line 10684 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r3,fpTOS);
LABEL2(f_min)
NEXT_P2;
}

LABEL(represent) /* represent ( r c_addr u -- n f1 f2 ) */
/*  */
NAME("represent")
{
DEF_CA
Float r;
Char * c_addr;
UCell u;
Cell n;
Bool f1;
Bool f2;
NEXT_P0;
vm_Float2r(fpTOS,r);
vm_Cell2c_(sp[1],c_addr);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += -1;
fp += 1;
{
#line 1979 "./prim"
char *sig;
size_t siglen;
int flag;
int decpt;
sig=ecvt(r, u, &decpt, &flag);
n=(r==0. ? 1 : decpt);
f1=FLAG(flag!=0);
f2=FLAG(isdigit((unsigned)(sig[0]))!=0);
siglen=strlen(sig);
if (siglen>u) /* happens in glibc-2.1.3 if 999.. is rounded up */
  siglen=u;
memcpy(c_addr,sig,siglen);
memset(c_addr+siglen,f2?'0':' ',u-siglen);
#line 10738 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputs(" f1=", vm_out); printarg_f(f1);
fputs(" f2=", vm_out); printarg_f(f2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n,sp[2]);
vm_f2Cell(f1,sp[1]);
vm_f2Cell(f2,spTOS);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(represent)
NEXT_P2;
}

LABEL(to_float) /* >float ( c_addr u -- flag ) */
/* Actual stack effect: ( c_addr u -- r t | f ).  Attempt to convert the
character string @i{c-addr u} to internal floating-point
representation. If the string represents a valid floating-point number
@i{r} is placed on the floating-point stack and @i{flag} is
true. Otherwise, @i{flag} is false. A string of blanks is a special
case and represents the floating-point number 0. */
NAME(">float")
{
DEF_CA
Char * c_addr;
UCell u;
Bool flag;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 1;
{
#line 2000 "./prim"
Float r;
flag = to_float(c_addr, u, &r);
if (flag) {
  IF_fpTOS(fp[0] = fpTOS);
  fp += -1;
  fpTOS = r;
}
#line 10790 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" flag=", vm_out); printarg_f(flag);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(flag,spTOS);
LABEL2(to_float)
NEXT_P2;
}

LABEL(f_abs) /* fabs ( r1 -- r2 ) */
/*  */
NAME("fabs")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2009 "./prim"
r2 = fabs(r1);
#line 10822 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_abs)
NEXT_P2;
}

LABEL(f_a_cos) /* facos ( r1 -- r2 ) */
/*  */
NAME("facos")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2012 "./prim"
r2 = acos(r1);
#line 10854 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_a_cos)
NEXT_P2;
}

LABEL(f_a_sine) /* fasin ( r1 -- r2 ) */
/*  */
NAME("fasin")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2015 "./prim"
r2 = asin(r1);
#line 10886 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_a_sine)
NEXT_P2;
}

LABEL(f_a_tan) /* fatan ( r1 -- r2 ) */
/*  */
NAME("fatan")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2018 "./prim"
r2 = atan(r1);
#line 10918 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_a_tan)
NEXT_P2;
}

LABEL(f_a_tan_two) /* fatan2 ( r1 r2 -- r3 ) */
/* @i{r1/r2}=tan(@i{r3}). ANS Forth does not require, but probably
intends this to be the inverse of @code{fsincos}. In gforth it is. */
NAME("fatan2")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fp[1],r1);
vm_Float2r(fpTOS,r2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
fputs(" r2=", vm_out); printarg_r(r2);
}
#endif
fp += 1;
{
#line 2023 "./prim"
r3 = atan2(r1,r2);
#line 10955 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r3,fpTOS);
LABEL2(f_a_tan_two)
NEXT_P2;
}

LABEL(f_cos) /* fcos ( r1 -- r2 ) */
/*  */
NAME("fcos")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2026 "./prim"
r2 = cos(r1);
#line 10987 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_cos)
NEXT_P2;
}

LABEL(f_e_x_p) /* fexp ( r1 -- r2 ) */
/*  */
NAME("fexp")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2029 "./prim"
r2 = exp(r1);
#line 11019 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_e_x_p)
NEXT_P2;
}

LABEL(f_e_x_p_m_one) /* fexpm1 ( r1 -- r2 ) */
/* @i{r2}=@i{e}**@i{r1}@minus{}1 */
NAME("fexpm1")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2033 "./prim"
#ifdef HAVE_EXPM1
extern double
#ifdef NeXT
              const
#endif
                    expm1(double);
r2 = expm1(r1);
#else
r2 = exp(r1)-1.;
#endif
#line 11060 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_e_x_p_m_one)
NEXT_P2;
}

LABEL(f_l_n) /* fln ( r1 -- r2 ) */
/*  */
NAME("fln")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2045 "./prim"
r2 = log(r1);
#line 11092 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_l_n)
NEXT_P2;
}

LABEL(f_l_n_p_one) /* flnp1 ( r1 -- r2 ) */
/* @i{r2}=ln(@i{r1}+1) */
NAME("flnp1")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2049 "./prim"
#ifdef HAVE_LOG1P
extern double
#ifdef NeXT
              const
#endif
                    log1p(double);
r2 = log1p(r1);
#else
r2 = log(r1+1.);
#endif
#line 11133 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_l_n_p_one)
NEXT_P2;
}

LABEL(f_log) /* flog ( r1 -- r2 ) */
/* The decimal logarithm. */
NAME("flog")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2062 "./prim"
r2 = log10(r1);
#line 11165 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_log)
NEXT_P2;
}

LABEL(f_a_log) /* falog ( r1 -- r2 ) */
/* @i{r2}=10**@i{r1} */
NAME("falog")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2066 "./prim"
extern double pow10(double);
r2 = pow10(r1);
#line 11198 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_a_log)
NEXT_P2;
}

LABEL(f_sine) /* fsin ( r1 -- r2 ) */
/*  */
NAME("fsin")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2070 "./prim"
r2 = sin(r1);
#line 11230 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_sine)
NEXT_P2;
}

LABEL(f_sine_cos) /* fsincos ( r1 -- r2 r3 ) */
/* @i{r2}=sin(@i{r1}), @i{r3}=cos(@i{r1}) */
NAME("fsincos")
{
DEF_CA
Float r1;
Float r2;
Float r3;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
fp += -1;
{
#line 2074 "./prim"
r2 = sin(r1);
r3 = cos(r1);
#line 11265 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputs(" r3=", vm_out); printarg_r(r3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fp[1]);
vm_r2Float(r3,fpTOS);
LABEL2(f_sine_cos)
NEXT_P2;
}

LABEL(f_square_root) /* fsqrt ( r1 -- r2 ) */
/*  */
NAME("fsqrt")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2078 "./prim"
r2 = sqrt(r1);
#line 11299 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_square_root)
NEXT_P2;
}

LABEL(f_tan) /* ftan ( r1 -- r2 ) */
/*  */
NAME("ftan")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2081 "./prim"
r2 = tan(r1);
#line 11331 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_tan)
NEXT_P2;
}

LABEL(f_cinch) /* fsinh ( r1 -- r2 ) */
/*  */
NAME("fsinh")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2086 "./prim"
r2 = sinh(r1);
#line 11363 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_cinch)
NEXT_P2;
}

LABEL(f_cosh) /* fcosh ( r1 -- r2 ) */
/*  */
NAME("fcosh")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2091 "./prim"
r2 = cosh(r1);
#line 11395 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_cosh)
NEXT_P2;
}

LABEL(f_tan_h) /* ftanh ( r1 -- r2 ) */
/*  */
NAME("ftanh")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2096 "./prim"
r2 = tanh(r1);
#line 11427 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_tan_h)
NEXT_P2;
}

LABEL(f_a_cinch) /* fasinh ( r1 -- r2 ) */
/*  */
NAME("fasinh")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2101 "./prim"
r2 = asinh(r1);
#line 11459 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_a_cinch)
NEXT_P2;
}

LABEL(f_a_cosh) /* facosh ( r1 -- r2 ) */
/*  */
NAME("facosh")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2106 "./prim"
r2 = acosh(r1);
#line 11491 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_a_cosh)
NEXT_P2;
}

LABEL(f_a_tan_h) /* fatanh ( r1 -- r2 ) */
/*  */
NAME("fatanh")
{
DEF_CA
Float r1;
Float r2;
NEXT_P0;
vm_Float2r(fpTOS,r1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r1=", vm_out); printarg_r(r1);
}
#endif
{
#line 2111 "./prim"
r2 = atanh(r1);
#line 11523 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r2=", vm_out); printarg_r(r2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r2,fpTOS);
LABEL2(f_a_tan_h)
NEXT_P2;
}

LABEL(s_floats) /* sfloats ( n1 -- n2 ) */
/* @i{n2} is the number of address units of @i{n1}
single-precision IEEE floating-point numbers. */
NAME("sfloats")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 2119 "./prim"
n2 = n1*sizeof(SFloat);
#line 11556 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(s_floats)
NEXT_P2;
}

LABEL(d_floats) /* dfloats ( n1 -- n2 ) */
/* @i{n2} is the number of address units of @i{n1}
double-precision IEEE floating-point numbers. */
NAME("dfloats")
{
DEF_CA
Cell n1;
Cell n2;
NEXT_P0;
vm_Cell2n(spTOS,n1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
}
#endif
{
#line 2124 "./prim"
n2 = n1*sizeof(DFloat);
#line 11589 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n2=", vm_out); printarg_n(n2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_n2Cell(n2,spTOS);
LABEL2(d_floats)
NEXT_P2;
}

LABEL(s_f_aligned) /* sfaligned ( c_addr -- sf_addr ) */
/* @i{sf-addr} is the first single-float-aligned address greater
than or equal to @i{c-addr}. */
NAME("sfaligned")
{
DEF_CA
Char * c_addr;
SFloat * sf_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
{
#line 2129 "./prim"
sf_addr = (SFloat *)((((Cell)c_addr)+(sizeof(SFloat)-1))&(-sizeof(SFloat)));
#line 11622 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" sf_addr=", vm_out); printarg_sf_(sf_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_sf_2Cell(sf_addr,spTOS);
LABEL2(s_f_aligned)
NEXT_P2;
}

LABEL(d_f_aligned) /* dfaligned ( c_addr -- df_addr ) */
/* @i{df-addr} is the first double-float-aligned address greater
than or equal to @i{c-addr}. */
NAME("dfaligned")
{
DEF_CA
Char * c_addr;
DFloat * df_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
{
#line 2136 "./prim"
df_addr = (DFloat *)((((Cell)c_addr)+(sizeof(DFloat)-1))&(-sizeof(DFloat)));
#line 11655 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" df_addr=", vm_out); printarg_df_(df_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_df_2Cell(df_addr,spTOS);
LABEL2(d_f_aligned)
NEXT_P2;
}

LABEL(v_star) /* v* ( f_addr1 nstride1 f_addr2 nstride2 ucount -- r ) */
/* dot-product: r=v1*v2.  The first element of v1 is at f_addr1, the
next at f_addr1+nstride1 and so on (similar for v2). Both vectors have
ucount elements. */
NAME("v*")
{
DEF_CA
Float * f_addr1;
Cell nstride1;
Float * f_addr2;
Cell nstride2;
UCell ucount;
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2f_(sp[4],f_addr1);
vm_Cell2n(sp[3],nstride1);
vm_Cell2f_(sp[2],f_addr2);
vm_Cell2n(sp[1],nstride2);
vm_Cell2u(spTOS,ucount);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" f_addr1=", vm_out); printarg_f_(f_addr1);
fputs(" nstride1=", vm_out); printarg_n(nstride1);
fputs(" f_addr2=", vm_out); printarg_f_(f_addr2);
fputs(" nstride2=", vm_out); printarg_n(nstride2);
fputs(" ucount=", vm_out); printarg_u(ucount);
}
#endif
sp += 5;
fp += -1;
{
#line 2144 "./prim"
r = v_star(f_addr1, nstride1, f_addr2, nstride2, ucount);
#line 11704 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(v_star)
NEXT_P2;
}

LABEL(faxpy) /* faxpy ( ra f_x nstridex f_y nstridey ucount -- ) */
/* vy=ra*vx+vy */
NAME("faxpy")
{
DEF_CA
Float ra;
Float * f_x;
Cell nstridex;
Float * f_y;
Cell nstridey;
UCell ucount;
NEXT_P0;
vm_Float2r(fpTOS,ra);
vm_Cell2f_(sp[4],f_x);
vm_Cell2n(sp[3],nstridex);
vm_Cell2f_(sp[2],f_y);
vm_Cell2n(sp[1],nstridey);
vm_Cell2u(spTOS,ucount);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" ra=", vm_out); printarg_r(ra);
fputs(" f_x=", vm_out); printarg_f_(f_x);
fputs(" nstridex=", vm_out); printarg_n(nstridex);
fputs(" f_y=", vm_out); printarg_f_(f_y);
fputs(" nstridey=", vm_out); printarg_n(nstridey);
fputs(" ucount=", vm_out); printarg_u(ucount);
}
#endif
sp += 5;
fp += 1;
{
#line 2152 "./prim"
faxpy(ra, f_x, nstridex, f_y, nstridey, ucount);
#line 11753 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
IF_fpTOS(fpTOS = fp[0]);
LABEL2(faxpy)
NEXT_P2;
}

GROUPADD(69)
#endif
GROUPADD(0)
#ifdef HAS_GLOCALS
GROUPADD(0)
GROUP( locals, 287)
LABEL(fetch_local_number) /* @local# ( #noffset -- w ) */
/*  */
NAME("@local#")
{
DEF_CA
Cell noffset;
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2n(IMM_ARG(IPTOS,305397795 ),noffset);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" noffset=", vm_out); printarg_n(noffset);
}
#endif
INC_IP(1);
sp += -1;
{
#line 2172 "./prim"
w = *(Cell *)(lp+noffset);
#line 11794 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(fetch_local_number)
NEXT_P2;
}

LABEL(fetch_local_zero) /* @local0 ( -- w ) */
/*  */
NAME("@local0")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2175 "./prim"
w = ((Cell *)lp)[0];
#line 11825 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(fetch_local_zero)
NEXT_P2;
}

LABEL(fetch_local_four) /* @local1 ( -- w ) */
/*  */
NAME("@local1")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2178 "./prim"
w = ((Cell *)lp)[1];
#line 11856 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(fetch_local_four)
NEXT_P2;
}

LABEL(fetch_local_eight) /* @local2 ( -- w ) */
/*  */
NAME("@local2")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2181 "./prim"
w = ((Cell *)lp)[2];
#line 11887 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(fetch_local_eight)
NEXT_P2;
}

LABEL(fetch_local_twelve) /* @local3 ( -- w ) */
/*  */
NAME("@local3")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2184 "./prim"
w = ((Cell *)lp)[3];
#line 11918 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(fetch_local_twelve)
NEXT_P2;
}

GROUPADD(5)
#ifdef HAS_FLOATING
LABEL(f_fetch_local_number) /* f@local# ( #noffset -- r ) */
/*  */
NAME("f@local#")
{
DEF_CA
Cell noffset;
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2n(IMM_ARG(IPTOS,305397796 ),noffset);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" noffset=", vm_out); printarg_n(noffset);
}
#endif
INC_IP(1);
fp += -1;
{
#line 2189 "./prim"
r = *(Float *)(lp+noffset);
#line 11955 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
LABEL2(f_fetch_local_number)
NEXT_P2;
}

LABEL(f_fetch_local_zero) /* f@local0 ( -- r ) */
/*  */
NAME("f@local0")
{
DEF_CA
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
fp += -1;
{
#line 2192 "./prim"
r = ((Float *)lp)[0];
#line 11986 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
LABEL2(f_fetch_local_zero)
NEXT_P2;
}

LABEL(f_fetch_local_eight) /* f@local1 ( -- r ) */
/*  */
NAME("f@local1")
{
DEF_CA
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
fp += -1;
{
#line 2195 "./prim"
r = ((Float *)lp)[1];
#line 12017 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
LABEL2(f_fetch_local_eight)
NEXT_P2;
}

GROUPADD(3)
#endif
LABEL(laddr_number) /* laddr# ( #noffset -- c_addr ) */
/*  */
NAME("laddr#")
{
DEF_CA
Cell noffset;
Char * c_addr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
vm_Cell2n(IMM_ARG(IPTOS,305397797 ),noffset);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" noffset=", vm_out); printarg_n(noffset);
}
#endif
INC_IP(1);
sp += -1;
{
#line 2200 "./prim"
/* this can also be used to implement lp@ */
c_addr = (Char *)(lp+noffset);
#line 12055 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr,spTOS);
LABEL2(laddr_number)
NEXT_P2;
}

LABEL(lp_plus_store_number) /* lp+!# ( #noffset -- ) */
/* used with negative immediate values it allocates memory on the
local stack, a positive immediate argument drops memory from the local
stack */
NAME("lp+!#")
{
DEF_CA
Cell noffset;
NEXT_P0;
vm_Cell2n(IMM_ARG(IPTOS,305397798 ),noffset);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" noffset=", vm_out); printarg_n(noffset);
}
#endif
INC_IP(1);
{
#line 2207 "./prim"
lp += noffset;
#line 12089 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(lp_plus_store_number)
NEXT_P2;
}

LABEL(minus_four_lp_plus_store) /* lp- ( -- ) */
/*  */
NAME("lp-")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2210 "./prim"
lp += -sizeof(Cell);
#line 12115 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(minus_four_lp_plus_store)
NEXT_P2;
}

LABEL(eight_lp_plus_store) /* lp+ ( -- ) */
/*  */
NAME("lp+")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2213 "./prim"
lp += sizeof(Float);
#line 12141 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(eight_lp_plus_store)
NEXT_P2;
}

LABEL(sixteen_lp_plus_store) /* lp+2 ( -- ) */
/*  */
NAME("lp+2")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2216 "./prim"
lp += 2*sizeof(Float);
#line 12167 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(sixteen_lp_plus_store)
NEXT_P2;
}

LABEL(lp_store) /* lp! ( c_addr -- ) */
/*  */
NAME("lp!")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2219 "./prim"
lp = (Address)c_addr;
#line 12197 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(lp_store)
NEXT_P2;
}

LABEL(to_l) /* >l ( w -- ) */
/*  */
NAME(">l")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += 1;
{
#line 2222 "./prim"
lp -= sizeof(Cell);
*(Cell *)lp = w;
#line 12229 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(to_l)
NEXT_P2;
}

GROUPADD(7)
#ifdef HAS_FLOATING
LABEL(f_to_l) /* f>l ( r -- ) */
/*  */
NAME("f>l")
{
DEF_CA
Float r;
NEXT_P0;
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
fp += 1;
{
#line 2228 "./prim"
lp -= sizeof(Float);
*(Float *)lp = r;
#line 12263 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_fpTOS(fpTOS = fp[0]);
LABEL2(f_to_l)
NEXT_P2;
}

LABEL(fpick) /* fpick ( u -- r ) */
/* Actually the stack effect is @code{ r0 ... ru u -- r0 ... ru r0 }. */
NAME("fpick")
{
DEF_CA
UCell u;
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 1;
fp += -1;
{
#line 2233 "./prim"
r = fp[u+1]; /* +1, because update of fp happens before this fragment */
#line 12297 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fpick)
NEXT_P2;
}

GROUPADD(2)
#endif
GROUPADD(0)
#endif
GROUPADD(0)
#ifdef HAS_OS
GROUPADD(0)
GROUP( syslib, 304)
LABEL(open_lib) /* open-lib ( c_addr1 u1 -- u2 ) */
/*  */
NAME("open-lib")
{
DEF_CA
Char * c_addr1;
UCell u1;
UCell u2;
NEXT_P0;
vm_Cell2c_(sp[1],c_addr1);
vm_Cell2u(spTOS,u1);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
fputs(" u1=", vm_out); printarg_u(u1);
}
#endif
sp += 1;
{
#line 2245 "./prim"
#if defined(HAVE_LIBDL) || defined(HAVE_DLOPEN)
#ifndef RTLD_GLOBAL
#define RTLD_GLOBAL 0
#endif
u2=(UCell) dlopen(cstr(c_addr1, u1, 1), RTLD_GLOBAL | RTLD_LAZY);
#else
#  ifdef _WIN32
u2 = (Cell) GetModuleHandle(cstr(c_addr1, u1, 1));
#  else
#warning Define open-lib!
u2 = 0;
#  endif
#endif
#line 12354 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u2=", vm_out); printarg_u(u2);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u2,spTOS);
LABEL2(open_lib)
NEXT_P2;
}

LABEL(lib_sym) /* lib-sym ( c_addr1 u1 u2 -- u3 ) */
/*  */
NAME("lib-sym")
{
DEF_CA
Char * c_addr1;
UCell u1;
UCell u2;
UCell u3;
NEXT_P0;
vm_Cell2c_(sp[2],c_addr1);
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr1=", vm_out); printarg_c_(c_addr1);
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
}
#endif
sp += 2;
{
#line 2260 "./prim"
#if defined(HAVE_LIBDL) || defined(HAVE_DLOPEN)
u3 = (UCell) dlsym((void*)u2,cstr(c_addr1, u1, 1));
#else
#  ifdef _WIN32
u3 = (Cell) GetProcAddress((HMODULE)u2, cstr(c_addr1, u1, 1));
#  else
#warning Define lib-sym!
u3 = 0;
#  endif
#endif
#line 12402 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" u3=", vm_out); printarg_u(u3);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(u3,spTOS);
LABEL2(lib_sym)
NEXT_P2;
}

LABEL(wcall) /* wcall ( u -- ) */
/*  */
NAME("wcall")
{
DEF_CA
UCell u;
NEXT_P0;
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 1;
{
#line 2272 "./prim"
IF_fpTOS(fp[0]=fpTOS);
FP=fp;
sp=(Cell*)(SYSCALL(Cell*(*)(Cell *, void *))u)(sp, &FP);
fp=FP;
IF_spTOS(spTOS=sp[0];)
IF_fpTOS(fpTOS=fp[0]);
#line 12439 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(wcall)
NEXT_P2;
}

GROUPADD(3)
#ifdef HAS_FFCALL
LABEL(av_start_void) /* av-start-void ( c_addr -- ) */
/*  */
NAME("av-start-void")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2282 "./prim"
av_start_void(alist, c_addr);
#line 12472 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_start_void)
NEXT_P2;
}

LABEL(av_start_int) /* av-start-int ( c_addr -- ) */
/*  */
NAME("av-start-int")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2285 "./prim"
av_start_int(alist, c_addr, &irv);
#line 12503 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_start_int)
NEXT_P2;
}

LABEL(av_start_float) /* av-start-float ( c_addr -- ) */
/*  */
NAME("av-start-float")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2288 "./prim"
av_start_float(alist, c_addr, &frv);
#line 12534 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_start_float)
NEXT_P2;
}

LABEL(av_start_double) /* av-start-double ( c_addr -- ) */
/*  */
NAME("av-start-double")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2291 "./prim"
av_start_double(alist, c_addr, &drv);
#line 12565 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_start_double)
NEXT_P2;
}

LABEL(av_start_longlong) /* av-start-longlong ( c_addr -- ) */
/*  */
NAME("av-start-longlong")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2294 "./prim"
av_start_longlong(alist, c_addr, &llrv);
#line 12596 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_start_longlong)
NEXT_P2;
}

LABEL(av_start_ptr) /* av-start-ptr ( c_addr -- ) */
/*  */
NAME("av-start-ptr")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2297 "./prim"
av_start_ptr(alist, c_addr, void*, &prv);
#line 12627 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_start_ptr)
NEXT_P2;
}

LABEL(av_int) /* av-int ( w -- ) */
/*  */
NAME("av-int")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += 1;
{
#line 2300 "./prim"
av_int(alist, w);
#line 12658 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_int)
NEXT_P2;
}

LABEL(av_float) /* av-float ( r -- ) */
/*  */
NAME("av-float")
{
DEF_CA
Float r;
NEXT_P0;
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
fp += 1;
{
#line 2303 "./prim"
av_float(alist, r);
#line 12689 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_fpTOS(fpTOS = fp[0]);
LABEL2(av_float)
NEXT_P2;
}

LABEL(av_double) /* av-double ( r -- ) */
/*  */
NAME("av-double")
{
DEF_CA
Float r;
NEXT_P0;
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
fp += 1;
{
#line 2306 "./prim"
av_double(alist, r);
#line 12720 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_fpTOS(fpTOS = fp[0]);
LABEL2(av_double)
NEXT_P2;
}

LABEL(av_longlong) /* av-longlong ( d -- ) */
/*  */
NAME("av-longlong")
{
DEF_CA
DCell d;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 2;
{
#line 2309 "./prim"
av_longlong(alist, d);
#line 12751 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_longlong)
NEXT_P2;
}

LABEL(av_ptr) /* av-ptr ( c_addr -- ) */
/*  */
NAME("av-ptr")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2312 "./prim"
av_ptr(alist, void*, c_addr);
#line 12782 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(av_ptr)
NEXT_P2;
}

LABEL(av_int_r) /* av-int-r ( R:w -- ) */
/*  */
NAME("av-int-r")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(rpTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
rp += 1;
{
#line 2315 "./prim"
av_int(alist, w);
#line 12813 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);
LABEL2(av_int_r)
NEXT_P2;
}

LABEL(av_float_r) /* av-float-r ( -- ) */
/*  */
NAME("av-float-r")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2318 "./prim"
float r = *(Float*)lp;
lp += sizeof(Float);
av_float(alist, r);
#line 12842 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(av_float_r)
NEXT_P2;
}

LABEL(av_double_r) /* av-double-r ( -- ) */
/*  */
NAME("av-double-r")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2323 "./prim"
double r = *(Float*)lp;
lp += sizeof(Float);
av_double(alist, r);
#line 12870 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(av_double_r)
NEXT_P2;
}

LABEL(av_longlong_r) /* av-longlong-r ( R:d -- ) */
/*  */
NAME("av-longlong-r")
{
DEF_CA
DCell d;
NEXT_P0;
vm_twoCell2d((Cell)rp[1], (Cell)rpTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
rp += 2;
{
#line 2328 "./prim"
av_longlong(alist, d);
#line 12900 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);
LABEL2(av_longlong_r)
NEXT_P2;
}

LABEL(av_ptr_r) /* av-ptr-r ( R:c_addr -- ) */
/*  */
NAME("av-ptr-r")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(rpTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
rp += 1;
{
#line 2331 "./prim"
av_ptr(alist, void*, c_addr);
#line 12931 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);
LABEL2(av_ptr_r)
NEXT_P2;
}

LABEL(av_call_void) /* av-call-void ( -- ) */
/*  */
NAME("av-call-void")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2334 "./prim"
SAVE_REGS
av_call(alist);
REST_REGS
#line 12960 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(av_call_void)
NEXT_P2;
}

LABEL(av_call_int) /* av-call-int ( -- w ) */
/*  */
NAME("av-call-int")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2339 "./prim"
SAVE_REGS
av_call(alist);
REST_REGS
w = irv;
#line 12992 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(av_call_int)
NEXT_P2;
}

LABEL(av_call_float) /* av-call-float ( -- r ) */
/*  */
NAME("av-call-float")
{
DEF_CA
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
fp += -1;
{
#line 2345 "./prim"
SAVE_REGS
av_call(alist);
REST_REGS
r = frv;
#line 13026 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
LABEL2(av_call_float)
NEXT_P2;
}

LABEL(av_call_double) /* av-call-double ( -- r ) */
/*  */
NAME("av-call-double")
{
DEF_CA
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
fp += -1;
{
#line 2351 "./prim"
SAVE_REGS
av_call(alist);
REST_REGS
r = drv;
#line 13060 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
LABEL2(av_call_double)
NEXT_P2;
}

LABEL(av_call_longlong) /* av-call-longlong ( -- d ) */
/*  */
NAME("av-call-longlong")
{
DEF_CA
DCell d;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -2;
{
#line 2357 "./prim"
SAVE_REGS
av_call(alist);
REST_REGS
d = llrv;
#line 13094 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d=", vm_out); printarg_d(d);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, sp[1], spTOS)
LABEL2(av_call_longlong)
NEXT_P2;
}

LABEL(av_call_ptr) /* av-call-ptr ( -- c_addr ) */
/*  */
NAME("av-call-ptr")
{
DEF_CA
Char * c_addr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2363 "./prim"
SAVE_REGS
av_call(alist);
REST_REGS
c_addr = prv;
#line 13128 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr,spTOS);
LABEL2(av_call_ptr)
NEXT_P2;
}

LABEL(alloc_callback) /* alloc-callback ( a_ip -- c_addr ) */
/*  */
NAME("alloc-callback")
{
DEF_CA
Cell * a_ip;
Char * c_addr;
NEXT_P0;
vm_Cell2a_(spTOS,a_ip);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_ip=", vm_out); printarg_a_(a_ip);
}
#endif
{
#line 2369 "./prim"
c_addr = (char *)alloc_callback(engine_callback, (Xt *)a_ip);
#line 13160 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr,spTOS);
LABEL2(alloc_callback)
NEXT_P2;
}

LABEL(va_start_void) /* va-start-void ( -- ) */
/*  */
NAME("va-start-void")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2372 "./prim"
va_start_void(clist);
#line 13188 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(va_start_void)
NEXT_P2;
}

LABEL(va_start_int) /* va-start-int ( -- ) */
/*  */
NAME("va-start-int")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2375 "./prim"
va_start_int(clist);
#line 13214 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(va_start_int)
NEXT_P2;
}

LABEL(va_start_longlong) /* va-start-longlong ( -- ) */
/*  */
NAME("va-start-longlong")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2378 "./prim"
va_start_longlong(clist);
#line 13240 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(va_start_longlong)
NEXT_P2;
}

LABEL(va_start_ptr) /* va-start-ptr ( -- ) */
/*  */
NAME("va-start-ptr")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2381 "./prim"
va_start_ptr(clist, (char *));
#line 13266 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(va_start_ptr)
NEXT_P2;
}

LABEL(va_start_float) /* va-start-float ( -- ) */
/*  */
NAME("va-start-float")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2384 "./prim"
va_start_float(clist);
#line 13292 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(va_start_float)
NEXT_P2;
}

LABEL(va_start_double) /* va-start-double ( -- ) */
/*  */
NAME("va-start-double")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2387 "./prim"
va_start_double(clist);
#line 13318 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(va_start_double)
NEXT_P2;
}

LABEL(va_arg_int) /* va-arg-int ( -- w ) */
/*  */
NAME("va-arg-int")
{
DEF_CA
Cell w;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2390 "./prim"
w = va_arg_int(clist);
#line 13347 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_w2Cell(w,spTOS);
LABEL2(va_arg_int)
NEXT_P2;
}

LABEL(va_arg_longlong) /* va-arg-longlong ( -- d ) */
/*  */
NAME("va-arg-longlong")
{
DEF_CA
DCell d;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -2;
{
#line 2393 "./prim"
d = va_arg_longlong(clist);
#line 13378 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" d=", vm_out); printarg_d(d);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_d2twoCell(d, sp[1], spTOS)
LABEL2(va_arg_longlong)
NEXT_P2;
}

LABEL(va_arg_ptr) /* va-arg-ptr ( -- c_addr ) */
/*  */
NAME("va-arg-ptr")
{
DEF_CA
Char * c_addr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2396 "./prim"
c_addr = (char *)va_arg_ptr(clist,char*);
#line 13409 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" c_addr=", vm_out); printarg_c_(c_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_c_2Cell(c_addr,spTOS);
LABEL2(va_arg_ptr)
NEXT_P2;
}

LABEL(va_arg_float) /* va-arg-float ( -- r ) */
/*  */
NAME("va-arg-float")
{
DEF_CA
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
fp += -1;
{
#line 2399 "./prim"
r = va_arg_float(clist);
#line 13440 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
LABEL2(va_arg_float)
NEXT_P2;
}

LABEL(va_arg_double) /* va-arg-double ( -- r ) */
/*  */
NAME("va-arg-double")
{
DEF_CA
Float r;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
fp += -1;
{
#line 2402 "./prim"
r = va_arg_double(clist);
#line 13471 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" r=", vm_out); printarg_r(r);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(r,fpTOS);
LABEL2(va_arg_double)
NEXT_P2;
}

LABEL(va_return_void) /* va-return-void ( -- ) */
/*  */
NAME("va-return-void")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2405 "./prim"
va_return_void(clist);
return 0;
#line 13500 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(va_return_void)
NEXT_P2;
}

LABEL(va_return_int) /* va-return-int ( w -- ) */
/*  */
NAME("va-return-int")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += 1;
{
#line 2409 "./prim"
va_return_int(clist, w);
return 0;
#line 13531 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(va_return_int)
NEXT_P2;
}

LABEL(va_return_ptr) /* va-return-ptr ( c_addr -- ) */
/*  */
NAME("va-return-ptr")
{
DEF_CA
Char * c_addr;
NEXT_P0;
vm_Cell2c_(spTOS,c_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_addr=", vm_out); printarg_c_(c_addr);
}
#endif
sp += 1;
{
#line 2413 "./prim"
va_return_ptr(clist, void *, c_addr);
return 0;
#line 13563 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(va_return_ptr)
NEXT_P2;
}

LABEL(va_return_longlong) /* va-return-longlong ( d -- ) */
/*  */
NAME("va-return-longlong")
{
DEF_CA
DCell d;
NEXT_P0;
vm_twoCell2d((Cell)sp[1], (Cell)spTOS, d)
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" d=", vm_out); printarg_d(d);
}
#endif
sp += 2;
{
#line 2417 "./prim"
va_return_longlong(clist, d);
return 0;
#line 13595 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(va_return_longlong)
NEXT_P2;
}

LABEL(va_return_float) /* va-return-float ( r -- ) */
/*  */
NAME("va-return-float")
{
DEF_CA
Float r;
NEXT_P0;
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
fp += 1;
{
#line 2421 "./prim"
va_return_float(clist, r);
return 0;
#line 13627 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_fpTOS(fpTOS = fp[0]);
LABEL2(va_return_float)
NEXT_P2;
}

LABEL(va_return_double) /* va-return-double ( r -- ) */
/*  */
NAME("va-return-double")
{
DEF_CA
Float r;
NEXT_P0;
vm_Float2r(fpTOS,r);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" r=", vm_out); printarg_r(r);
}
#endif
fp += 1;
{
#line 2425 "./prim"
va_return_double(clist, r);
return 0;
#line 13659 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_fpTOS(fpTOS = fp[0]);
LABEL2(va_return_double)
NEXT_P2;
}

GROUPADD(40)
#endif
GROUPADD(0)
#ifdef HAS_OLDCALL
LABEL(icall0) /* icall0 ( u -- uret ) */
/*  */
NAME("icall0")
{
DEF_CA
UCell u;
UCell uret;
NEXT_P0;
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
{
#line 2463 "./prim"
uret = (SYSCALL(Cell(*)())u)();
#line 2462
#line 13695 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" uret=", vm_out); printarg_u(uret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(uret,spTOS);
LABEL2(icall0)
NEXT_P2;
}

LABEL(icall1) /* icall1 ( u1 u -- uret ) */
/*  */
NAME("icall1")
{
DEF_CA
UCell u1;
UCell u;
UCell uret;
NEXT_P0;
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 1;
{
#line 2463 "./prim"
uret = (SYSCALL(Cell(*)(Cell))u)(u1);
#line 2462
#line 13732 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" uret=", vm_out); printarg_u(uret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(uret,spTOS);
LABEL2(icall1)
NEXT_P2;
}

LABEL(icall2) /* icall2 ( u1 u2 u -- uret ) */
/*  */
NAME("icall2")
{
DEF_CA
UCell u1;
UCell u2;
UCell u;
UCell uret;
NEXT_P0;
vm_Cell2u(sp[2],u1);
vm_Cell2u(sp[1],u2);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 2;
{
#line 2463 "./prim"
uret = (SYSCALL(Cell(*)(Cell, Cell))u)(u1, u2);
#line 2462
#line 13772 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" uret=", vm_out); printarg_u(uret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(uret,spTOS);
LABEL2(icall2)
NEXT_P2;
}

LABEL(icall3) /* icall3 ( u1 u2 u3 u -- uret ) */
/*  */
NAME("icall3")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u;
UCell uret;
NEXT_P0;
vm_Cell2u(sp[3],u1);
vm_Cell2u(sp[2],u2);
vm_Cell2u(sp[1],u3);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 3;
{
#line 2463 "./prim"
uret = (SYSCALL(Cell(*)(Cell, Cell, Cell))u)(u1, u2, u3);
#line 2462
#line 13815 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" uret=", vm_out); printarg_u(uret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(uret,spTOS);
LABEL2(icall3)
NEXT_P2;
}

LABEL(icall4) /* icall4 ( u1 u2 u3 u4 u -- uret ) */
/*  */
NAME("icall4")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u4;
UCell u;
UCell uret;
NEXT_P0;
vm_Cell2u(sp[4],u1);
vm_Cell2u(sp[3],u2);
vm_Cell2u(sp[2],u3);
vm_Cell2u(sp[1],u4);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u4=", vm_out); printarg_u(u4);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 4;
{
#line 2463 "./prim"
uret = (SYSCALL(Cell(*)(Cell, Cell, Cell, Cell))u)(u1, u2, u3, u4);
#line 2462
#line 13861 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" uret=", vm_out); printarg_u(uret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(uret,spTOS);
LABEL2(icall4)
NEXT_P2;
}

LABEL(icall5) /* icall5 ( u1 u2 u3 u4 u5 u -- uret ) */
/*  */
NAME("icall5")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u4;
UCell u5;
UCell u;
UCell uret;
NEXT_P0;
vm_Cell2u(sp[5],u1);
vm_Cell2u(sp[4],u2);
vm_Cell2u(sp[3],u3);
vm_Cell2u(sp[2],u4);
vm_Cell2u(sp[1],u5);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u4=", vm_out); printarg_u(u4);
fputs(" u5=", vm_out); printarg_u(u5);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 5;
{
#line 2463 "./prim"
uret = (SYSCALL(Cell(*)(Cell, Cell, Cell, Cell, Cell))u)(u1, u2, u3, u4, u5);
#line 2462
#line 13910 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" uret=", vm_out); printarg_u(uret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(uret,spTOS);
LABEL2(icall5)
NEXT_P2;
}

LABEL(icall6) /* icall6 ( u1 u2 u3 u4 u5 u6 u -- uret ) */
/*  */
NAME("icall6")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u4;
UCell u5;
UCell u6;
UCell u;
UCell uret;
NEXT_P0;
vm_Cell2u(sp[6],u1);
vm_Cell2u(sp[5],u2);
vm_Cell2u(sp[4],u3);
vm_Cell2u(sp[3],u4);
vm_Cell2u(sp[2],u5);
vm_Cell2u(sp[1],u6);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u4=", vm_out); printarg_u(u4);
fputs(" u5=", vm_out); printarg_u(u5);
fputs(" u6=", vm_out); printarg_u(u6);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 6;
{
#line 2463 "./prim"
uret = (SYSCALL(Cell(*)(Cell, Cell, Cell, Cell, Cell, Cell))u)(u1, u2, u3, u4, u5, u6);
#line 2462
#line 13962 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" uret=", vm_out); printarg_u(uret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(uret,spTOS);
LABEL2(icall6)
NEXT_P2;
}

LABEL(icall20) /* icall20 ( u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15 u16 u17 u18 u19 u20 u -- uret ) */
/*  */
NAME("icall20")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u4;
UCell u5;
UCell u6;
UCell u7;
UCell u8;
UCell u9;
UCell u10;
UCell u11;
UCell u12;
UCell u13;
UCell u14;
UCell u15;
UCell u16;
UCell u17;
UCell u18;
UCell u19;
UCell u20;
UCell u;
UCell uret;
NEXT_P0;
vm_Cell2u(sp[20],u1);
vm_Cell2u(sp[19],u2);
vm_Cell2u(sp[18],u3);
vm_Cell2u(sp[17],u4);
vm_Cell2u(sp[16],u5);
vm_Cell2u(sp[15],u6);
vm_Cell2u(sp[14],u7);
vm_Cell2u(sp[13],u8);
vm_Cell2u(sp[12],u9);
vm_Cell2u(sp[11],u10);
vm_Cell2u(sp[10],u11);
vm_Cell2u(sp[9],u12);
vm_Cell2u(sp[8],u13);
vm_Cell2u(sp[7],u14);
vm_Cell2u(sp[6],u15);
vm_Cell2u(sp[5],u16);
vm_Cell2u(sp[4],u17);
vm_Cell2u(sp[3],u18);
vm_Cell2u(sp[2],u19);
vm_Cell2u(sp[1],u20);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u4=", vm_out); printarg_u(u4);
fputs(" u5=", vm_out); printarg_u(u5);
fputs(" u6=", vm_out); printarg_u(u6);
fputs(" u7=", vm_out); printarg_u(u7);
fputs(" u8=", vm_out); printarg_u(u8);
fputs(" u9=", vm_out); printarg_u(u9);
fputs(" u10=", vm_out); printarg_u(u10);
fputs(" u11=", vm_out); printarg_u(u11);
fputs(" u12=", vm_out); printarg_u(u12);
fputs(" u13=", vm_out); printarg_u(u13);
fputs(" u14=", vm_out); printarg_u(u14);
fputs(" u15=", vm_out); printarg_u(u15);
fputs(" u16=", vm_out); printarg_u(u16);
fputs(" u17=", vm_out); printarg_u(u17);
fputs(" u18=", vm_out); printarg_u(u18);
fputs(" u19=", vm_out); printarg_u(u19);
fputs(" u20=", vm_out); printarg_u(u20);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 20;
{
#line 2464 "./prim"
uret = (SYSCALL(Cell(*)(Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell))u)(u1, u2, u3, u4, u5, u6, u7, u8, u9, u10, u11, u12, u13, u14, u15, u16, u17, u18, u19, u20);
#line 2463
#line 14056 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" uret=", vm_out); printarg_u(uret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_u2Cell(uret,spTOS);
LABEL2(icall20)
NEXT_P2;
}

LABEL(fcall0) /* fcall0 ( u -- rret ) */
/*  */
NAME("fcall0")
{
DEF_CA
UCell u;
Float rret;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 1;
fp += -1;
{
#line 2465 "./prim"
rret = (SYSCALL(Float(*)())u)();
#line 2464
#line 14092 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" rret=", vm_out); printarg_r(rret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(rret,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fcall0)
NEXT_P2;
}

LABEL(fcall1) /* fcall1 ( u1 u -- rret ) */
/*  */
NAME("fcall1")
{
DEF_CA
UCell u1;
UCell u;
Float rret;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(sp[1],u1);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 2;
fp += -1;
{
#line 2465 "./prim"
rret = (SYSCALL(Float(*)(Cell))u)(u1);
#line 2464
#line 14132 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" rret=", vm_out); printarg_r(rret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(rret,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fcall1)
NEXT_P2;
}

LABEL(fcall2) /* fcall2 ( u1 u2 u -- rret ) */
/*  */
NAME("fcall2")
{
DEF_CA
UCell u1;
UCell u2;
UCell u;
Float rret;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(sp[2],u1);
vm_Cell2u(sp[1],u2);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 3;
fp += -1;
{
#line 2465 "./prim"
rret = (SYSCALL(Float(*)(Cell, Cell))u)(u1, u2);
#line 2464
#line 14175 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" rret=", vm_out); printarg_r(rret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(rret,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fcall2)
NEXT_P2;
}

LABEL(fcall3) /* fcall3 ( u1 u2 u3 u -- rret ) */
/*  */
NAME("fcall3")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u;
Float rret;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(sp[3],u1);
vm_Cell2u(sp[2],u2);
vm_Cell2u(sp[1],u3);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 4;
fp += -1;
{
#line 2465 "./prim"
rret = (SYSCALL(Float(*)(Cell, Cell, Cell))u)(u1, u2, u3);
#line 2464
#line 14221 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" rret=", vm_out); printarg_r(rret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(rret,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fcall3)
NEXT_P2;
}

LABEL(fcall4) /* fcall4 ( u1 u2 u3 u4 u -- rret ) */
/*  */
NAME("fcall4")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u4;
UCell u;
Float rret;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(sp[4],u1);
vm_Cell2u(sp[3],u2);
vm_Cell2u(sp[2],u3);
vm_Cell2u(sp[1],u4);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u4=", vm_out); printarg_u(u4);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 5;
fp += -1;
{
#line 2465 "./prim"
rret = (SYSCALL(Float(*)(Cell, Cell, Cell, Cell))u)(u1, u2, u3, u4);
#line 2464
#line 14270 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" rret=", vm_out); printarg_r(rret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(rret,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fcall4)
NEXT_P2;
}

LABEL(fcall5) /* fcall5 ( u1 u2 u3 u4 u5 u -- rret ) */
/*  */
NAME("fcall5")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u4;
UCell u5;
UCell u;
Float rret;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(sp[5],u1);
vm_Cell2u(sp[4],u2);
vm_Cell2u(sp[3],u3);
vm_Cell2u(sp[2],u4);
vm_Cell2u(sp[1],u5);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u4=", vm_out); printarg_u(u4);
fputs(" u5=", vm_out); printarg_u(u5);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 6;
fp += -1;
{
#line 2465 "./prim"
rret = (SYSCALL(Float(*)(Cell, Cell, Cell, Cell, Cell))u)(u1, u2, u3, u4, u5);
#line 2464
#line 14322 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" rret=", vm_out); printarg_r(rret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(rret,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fcall5)
NEXT_P2;
}

LABEL(fcall6) /* fcall6 ( u1 u2 u3 u4 u5 u6 u -- rret ) */
/*  */
NAME("fcall6")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u4;
UCell u5;
UCell u6;
UCell u;
Float rret;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(sp[6],u1);
vm_Cell2u(sp[5],u2);
vm_Cell2u(sp[4],u3);
vm_Cell2u(sp[3],u4);
vm_Cell2u(sp[2],u5);
vm_Cell2u(sp[1],u6);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u4=", vm_out); printarg_u(u4);
fputs(" u5=", vm_out); printarg_u(u5);
fputs(" u6=", vm_out); printarg_u(u6);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 7;
fp += -1;
{
#line 2465 "./prim"
rret = (SYSCALL(Float(*)(Cell, Cell, Cell, Cell, Cell, Cell))u)(u1, u2, u3, u4, u5, u6);
#line 2464
#line 14377 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" rret=", vm_out); printarg_r(rret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(rret,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fcall6)
NEXT_P2;
}

LABEL(fcall20) /* fcall20 ( u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15 u16 u17 u18 u19 u20 u -- rret ) */
/*  */
NAME("fcall20")
{
DEF_CA
UCell u1;
UCell u2;
UCell u3;
UCell u4;
UCell u5;
UCell u6;
UCell u7;
UCell u8;
UCell u9;
UCell u10;
UCell u11;
UCell u12;
UCell u13;
UCell u14;
UCell u15;
UCell u16;
UCell u17;
UCell u18;
UCell u19;
UCell u20;
UCell u;
Float rret;
NEXT_P0;
IF_fpTOS(fp[0] = fpTOS);
vm_Cell2u(sp[20],u1);
vm_Cell2u(sp[19],u2);
vm_Cell2u(sp[18],u3);
vm_Cell2u(sp[17],u4);
vm_Cell2u(sp[16],u5);
vm_Cell2u(sp[15],u6);
vm_Cell2u(sp[14],u7);
vm_Cell2u(sp[13],u8);
vm_Cell2u(sp[12],u9);
vm_Cell2u(sp[11],u10);
vm_Cell2u(sp[10],u11);
vm_Cell2u(sp[9],u12);
vm_Cell2u(sp[8],u13);
vm_Cell2u(sp[7],u14);
vm_Cell2u(sp[6],u15);
vm_Cell2u(sp[5],u16);
vm_Cell2u(sp[4],u17);
vm_Cell2u(sp[3],u18);
vm_Cell2u(sp[2],u19);
vm_Cell2u(sp[1],u20);
vm_Cell2u(spTOS,u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u1=", vm_out); printarg_u(u1);
fputs(" u2=", vm_out); printarg_u(u2);
fputs(" u3=", vm_out); printarg_u(u3);
fputs(" u4=", vm_out); printarg_u(u4);
fputs(" u5=", vm_out); printarg_u(u5);
fputs(" u6=", vm_out); printarg_u(u6);
fputs(" u7=", vm_out); printarg_u(u7);
fputs(" u8=", vm_out); printarg_u(u8);
fputs(" u9=", vm_out); printarg_u(u9);
fputs(" u10=", vm_out); printarg_u(u10);
fputs(" u11=", vm_out); printarg_u(u11);
fputs(" u12=", vm_out); printarg_u(u12);
fputs(" u13=", vm_out); printarg_u(u13);
fputs(" u14=", vm_out); printarg_u(u14);
fputs(" u15=", vm_out); printarg_u(u15);
fputs(" u16=", vm_out); printarg_u(u16);
fputs(" u17=", vm_out); printarg_u(u17);
fputs(" u18=", vm_out); printarg_u(u18);
fputs(" u19=", vm_out); printarg_u(u19);
fputs(" u20=", vm_out); printarg_u(u20);
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += 21;
fp += -1;
{
#line 2466 "./prim"
rret = (SYSCALL(Float(*)(Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell, Cell))u)(u1, u2, u3, u4, u5, u6, u7, u8, u9, u10, u11, u12, u13, u14, u15, u16, u17, u18, u19, u20);
#line 2465
#line 14474 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" rret=", vm_out); printarg_r(rret);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_r2Float(rret,fpTOS);
IF_spTOS(spTOS = sp[0]);
LABEL2(fcall20)
NEXT_P2;
}

GROUPADD(16)
#endif
GROUPADD(0)
#endif
GROUPADD(0)
GROUP( peephole, 363)
GROUPADD(0)
#ifdef HAS_PEEPHOLE
LABEL(compile_prim1) /* compile-prim1 ( a_prim -- ) */
/* compile prim (incl. immargs) at @var{a_prim} */
NAME("compile-prim1")
{
DEF_CA
Cell * a_prim;
NEXT_P0;
vm_Cell2a_(spTOS,a_prim);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_prim=", vm_out); printarg_a_(a_prim);
}
#endif
sp += 1;
{
#line 2477 "./prim"
compile_prim1(a_prim);
#line 14515 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(compile_prim1)
NEXT_P2;
}

LABEL(finish_code) /* finish-code ( -- ) */
/* Perform delayed steps in code generation (branch resolution, I-cache
flushing). */
NAME("finish-code")
{
DEF_CA
NEXT_P0;
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
{
#line 2482 "./prim"
finish_code();
#line 14543 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(finish_code)
NEXT_P2;
}

LABEL(forget_dyncode) /* forget-dyncode ( c_code -- f ) */
/*  */
NAME("forget-dyncode")
{
DEF_CA
Char * c_code;
Bool f;
NEXT_P0;
vm_Cell2c_(spTOS,c_code);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" c_code=", vm_out); printarg_c_(c_code);
}
#endif
{
#line 2485 "./prim"
f = forget_dyncode(c_code);
#line 14573 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_f2Cell(f,spTOS);
LABEL2(forget_dyncode)
NEXT_P2;
}

LABEL(decompile_prim) /* decompile-prim ( a_code -- a_prim ) */
/* a_prim is the code address of the primitive that has been
compile_prim1ed to a_code */
NAME("decompile-prim")
{
DEF_CA
Cell * a_code;
Cell * a_prim;
NEXT_P0;
vm_Cell2a_(spTOS,a_code);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_code=", vm_out); printarg_a_(a_code);
}
#endif
{
#line 2490 "./prim"
a_prim = (Cell *)decompile_code((Label)a_code);
#line 14606 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_prim=", vm_out); printarg_a_(a_prim);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_prim,spTOS);
LABEL2(decompile_prim)
NEXT_P2;
}

LABEL(set_next_code) /* set-next-code ( #w -- ) */
/*  */
NAME("set-next-code")
{
DEF_CA
Cell w;
NEXT_P0;
vm_Cell2w(IMM_ARG(IPTOS,305397799 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(1);
{
#line 2496 "./prim"
#ifdef NO_IP
next_code = (Label)w;
#endif
#line 14640 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
LABEL2(set_next_code)
NEXT_P2;
}

LABEL(call2) /* call2 ( #a_callee #a_ret_addr -- R:a_ret_addr ) */
/*  */
NAME("call2")
{
DEF_CA
Cell * a_callee;
Cell * a_ret_addr;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
vm_Cell2a_(IMM_ARG(IPTOS,305397800 ),a_callee);
vm_Cell2a_(IMM_ARG(IP[1],305397801 ),a_ret_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_callee=", vm_out); printarg_a_(a_callee);
fputs(" a_ret_addr=", vm_out); printarg_a_(a_ret_addr);
}
#endif
INC_IP(2);
rp += -1;
{
#line 2501 "./prim"
/* call with explicit return address */
#ifdef NO_IP

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_ret_addr,rpTOS);

JUMP(a_callee);
#else
assert(0);
#endif
#line 14689 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_ret_addr,rpTOS);
LABEL2(call2)
NEXT_P2;
}

LABEL(tag_offsets) /* tag-offsets ( -- a_addr ) */
/*  */
NAME("tag-offsets")
{
DEF_CA
Cell * a_addr;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
#ifdef VM_DEBUG
if (vm_debug) {
}
#endif
sp += -1;
{
#line 2510 "./prim"
extern Cell groups[32];
a_addr = groups;
#line 14720 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr=", vm_out); printarg_a_(a_addr);
fputc('\n', vm_out);
}
#endif
NEXT_P1;
vm_a_2Cell(a_addr,spTOS);
LABEL2(tag_offsets)
NEXT_P2;
}

GROUPADD(7)
#endif
GROUPADD(0)
GROUP( static_super, 370)
 #if !defined(GFORTH_DEBUGGING) && !defined(INDIRECT_THREADED) && !defined(DOUBLY_INDIRECT) && !defined(VM_PROFILING)
LABEL(super1)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397802 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 14760 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* + ( n1 n2 -- n ) */
NAME("+")
{
Cell n1;
Cell n2;
Cell n;
vm_Cell2n(spTOS,n1);
vm_Cell2n(_sp1,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
n = n1+n2;
#line 14788 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
vm_n2Cell(n,spTOS);
}
NEXT_P1;
LABEL2(super1)
NEXT_P2;
}

LABEL(super2)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _rp0;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
IF_rpTOS(rp[0] = rpTOS);
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397803 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -1;
rp += -1;
{
#line 2510 "./prim"
#line 14829 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
/* call ( #a_callee -- R:a_retaddr ) */
NAME("call")
{
Cell * a_callee;
Cell * a_retaddr;
vm_Cell2a_(IMM_ARG(IP[2],305397804 ),a_callee);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_callee=", vm_out); printarg_a_(a_callee);
}
#endif
INC_IP(3);
{
#line 2510 "./prim"
#ifdef NO_IP

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_retaddr,rpTOS);
SUPER_END;
NEXT_P1;

JUMP(a_callee);
#else
#ifdef DEBUG
    {
      CFA_TO_NAME((((Cell *)a_callee)-2));
      fprintf(stderr,"%08lx: call %08lx %.*s\n",(Cell)ip,(Cell)a_callee,
	      len,name);
    }
#endif
a_retaddr = (Cell *)IP;
SET_IP((Xt *)a_callee);
#endif
#line 14877 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_retaddr,rpTOS);
}
SUPER_END;
NEXT_P1;
LABEL2(super2)
NEXT_P2;
}

LABEL(super3)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397805 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -1;
{
#line 2510 "./prim"
#line 14915 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp0);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp0,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
w = *a_addr;
#line 14940 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super3)
NEXT_P2;
}

LABEL(super4)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _IP3;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _rp0;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
IF_rpTOS(rp[0] = rpTOS);
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397806 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -1;
rp += -1;
{
#line 2510 "./prim"
#line 14982 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp0);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp0,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
{
#line 2510 "./prim"
w = *a_addr;
#line 15006 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
/* call ( #a_callee -- R:a_retaddr ) */
NAME("call")
{
Cell * a_callee;
Cell * a_retaddr;
vm_Cell2a_(IMM_ARG(IP[3],305397807 ),a_callee);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_callee=", vm_out); printarg_a_(a_callee);
}
#endif
INC_IP(4);
{
#line 2510 "./prim"
#ifdef NO_IP

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_retaddr,rpTOS);
SUPER_END;
NEXT_P1;

JUMP(a_callee);
#else
#ifdef DEBUG
    {
      CFA_TO_NAME((((Cell *)a_callee)-2));
      fprintf(stderr,"%08lx: call %08lx %.*s\n",(Cell)ip,(Cell)a_callee,
	      len,name);
    }
#endif
a_retaddr = (Cell *)IP;
SET_IP((Xt *)a_callee);
#endif
#line 15055 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_retaddr,rpTOS);
}
SUPER_END;
NEXT_P1;
LABEL2(super4)
NEXT_P2;
}

LABEL(super5)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _rp0;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
rp += -1;
{
#line 2510 "./prim"
w = *a_addr;
#line 15096 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
/* call ( #a_callee -- R:a_retaddr ) */
NAME("call")
{
Cell * a_callee;
Cell * a_retaddr;
vm_Cell2a_(IMM_ARG(IP[1],305397808 ),a_callee);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_callee=", vm_out); printarg_a_(a_callee);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
#ifdef NO_IP

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_retaddr,rpTOS);
SUPER_END;
NEXT_P1;

JUMP(a_callee);
#else
#ifdef DEBUG
    {
      CFA_TO_NAME((((Cell *)a_callee)-2));
      fprintf(stderr,"%08lx: call %08lx %.*s\n",(Cell)ip,(Cell)a_callee,
	      len,name);
    }
#endif
a_retaddr = (Cell *)IP;
SET_IP((Xt *)a_callee);
#endif
#line 15145 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_retaddr,rpTOS);
}
SUPER_END;
NEXT_P1;
LABEL2(super5)
NEXT_P2;
}

LABEL(super6)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397809 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 15182 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* ! ( w a_addr -- ) */
NAME("!")
{
Cell w;
Cell * a_addr;
vm_Cell2w(spTOS,w);
vm_Cell2a_(_sp1,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(2);
sp += 1;
{
#line 2510 "./prim"
*a_addr = w;
#line 15210 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(super6)
NEXT_P2;
}

LABEL(super7)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397810 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -2;
{
#line 2510 "./prim"
#line 15248 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,sp[1]);
}
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IP[2],305397811 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(3);
{
#line 2510 "./prim"
#line 15271 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super7)
NEXT_P2;
}

LABEL(super8)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
Cell MAYBE_UNUSED _sp2;
NEXT_P0;
/* dup ( w -- w w ) */
NAME("dup")
{
Cell w;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -2;
{
#line 2510 "./prim"
#line 15308 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,sp[2]);
vm_w2Cell(w,sp[1]);
}
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IP[1],305397812 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
#line 15332 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super8)
NEXT_P2;
}

LABEL(super9)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* ! ( w a_addr -- ) */
NAME("!")
{
Cell w;
Cell * a_addr;
vm_Cell2w(sp[1],w);
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 1;
{
#line 2510 "./prim"
*a_addr = w;
#line 15372 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IP[1],305397813 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
#line 15394 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super9)
NEXT_P2;
}

LABEL(super10)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _IP3;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397814 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 15431 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* ! ( w a_addr -- ) */
NAME("!")
{
Cell w;
Cell * a_addr;
vm_Cell2w(spTOS,w);
vm_Cell2a_(_sp1,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
{
#line 2510 "./prim"
*a_addr = w;
#line 15457 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IP[3],305397815 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(4);
{
#line 2510 "./prim"
#line 15479 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super10)
NEXT_P2;
}

LABEL(super11)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
Cell MAYBE_UNUSED _rp0;
NEXT_P0;
/* ! ( w a_addr -- ) */
NAME("!")
{
Cell w;
Cell * a_addr;
vm_Cell2w(sp[1],w);
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 2;
{
#line 2510 "./prim"
*a_addr = w;
#line 15519 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
/* ;s ( R:w -- ) */
NAME(";s")
{
Cell w;
vm_Cell2w(rpTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(1);
rp += 1;
{
#line 2510 "./prim"
#ifdef NO_IP

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
IF_rpTOS(rpTOS = rp[0]);

goto *(void *)w;
#else
SET_IP((Xt *)w);
#endif
#line 15558 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
IF_rpTOS(rpTOS = rp[0]);
LABEL2(super11)
NEXT_P2;
}

LABEL(super12)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397816 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 15596 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* + ( n1 n2 -- n ) */
NAME("+")
{
Cell n1;
Cell n2;
Cell n;
vm_Cell2n(spTOS,n1);
vm_Cell2n(_sp1,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
{
#line 2510 "./prim"
n = n1+n2;
#line 15623 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
vm_n2Cell(n,_sp0);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp0,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(3);
{
#line 2510 "./prim"
w = *a_addr;
#line 15649 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super12)
NEXT_P2;
}

LABEL(super13)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
NEXT_P0;
/* 0= ( n -- f ) */
NAME("0=")
{
Cell n;
Bool f;
vm_Cell2n(spTOS,n);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n=", vm_out); printarg_n(n);
}
#endif
sp += 1;
{
#line 2510 "./prim"
f = FLAG(n==0);
#line 1012
#line 15688 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
vm_f2Cell(f,_sp0);
}
/* ?branch ( #a_target f -- ) */
NAME("?branch")
{
Cell * a_target;
Bool f;
vm_Cell2a_(IMM_ARG(IP[1],305397817 ),a_target);
vm_Cell2f(_sp0,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
	#ifdef NO_IP
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);

#line 337
#endif
#line 337
if (f==0) {
#line 337
	#ifdef NO_IP
#line 337
JUMP(a_target);
#line 337
#else
#line 337
SET_IP((Xt *)a_target);
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 337
#endif
#line 337
}
#line 337
SUPER_CONTINUE;
#line 337
#line 15757 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(super13)
NEXT_P2;
}

LABEL(super14)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
Cell MAYBE_UNUSED _rp0;
NEXT_P0;
IF_rpTOS(rp[0] = rpTOS);
/* dup ( w -- w w ) */
NAME("dup")
{
Cell w;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -1;
rp += -1;
{
#line 2510 "./prim"
#line 15797 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,sp[1]);
vm_w2Cell(w,spTOS);
}
/* call ( #a_callee -- R:a_retaddr ) */
NAME("call")
{
Cell * a_callee;
Cell * a_retaddr;
vm_Cell2a_(IMM_ARG(IP[1],305397818 ),a_callee);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_callee=", vm_out); printarg_a_(a_callee);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
#ifdef NO_IP

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_retaddr,rpTOS);
SUPER_END;
NEXT_P1;

JUMP(a_callee);
#else
#ifdef DEBUG
    {
      CFA_TO_NAME((((Cell *)a_callee)-2));
      fprintf(stderr,"%08lx: call %08lx %.*s\n",(Cell)ip,(Cell)a_callee,
	      len,name);
    }
#endif
a_retaddr = (Cell *)IP;
SET_IP((Xt *)a_callee);
#endif
#line 15846 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_retaddr=", vm_out); printarg_a_(a_retaddr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_retaddr,rpTOS);
}
SUPER_END;
NEXT_P1;
LABEL2(super14)
NEXT_P2;
}

LABEL(super15)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
NEXT_P0;
IF_spTOS(sp[0] = spTOS);
/* useraddr ( #u -- a_addr ) */
NAME("useraddr")
{
UCell u;
Cell * a_addr;
vm_Cell2u(IMM_ARG(IPTOS,305397819 ),u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
sp += -1;
{
#line 2510 "./prim"
a_addr = (Cell *)(up+u);
#line 15886 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr=", vm_out); printarg_a_(a_addr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_addr,_sp0);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp0,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
w = *a_addr;
#line 15912 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super15)
NEXT_P2;
}

LABEL(super16)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* + ( n1 n2 -- n ) */
NAME("+")
{
Cell n1;
Cell n2;
Cell n;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 1;
{
#line 2510 "./prim"
n = n1+n2;
#line 15953 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
vm_n2Cell(n,_sp0);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp0,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(1);
{
#line 2510 "./prim"
w = *a_addr;
#line 15979 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super16)
NEXT_P2;
}

LABEL(super17)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _IP3;
Cell MAYBE_UNUSED _sp0;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397820 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 16016 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp0);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp0,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
{
#line 2510 "./prim"
w = *a_addr;
#line 16040 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp0);
}
/* ?branch ( #a_target f -- ) */
NAME("?branch")
{
Cell * a_target;
Bool f;
vm_Cell2a_(IMM_ARG(IP[3],305397821 ),a_target);
vm_Cell2f(_sp0,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(4);
{
#line 2510 "./prim"
	#ifdef NO_IP
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;

#line 337
#endif
#line 337
if (f==0) {
#line 337
	#ifdef NO_IP
#line 337
JUMP(a_target);
#line 337
#else
#line 337
SET_IP((Xt *)a_target);
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
 NEXT_P2;
#line 337
#endif
#line 337
}
#line 337
SUPER_CONTINUE;
#line 337
#line 16107 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
SUPER_END;
NEXT_P1;
LABEL2(super17)
NEXT_P2;
}

LABEL(super18)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
Cell MAYBE_UNUSED _rp0;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397822 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 16144 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* ! ( w a_addr -- ) */
NAME("!")
{
Cell w;
Cell * a_addr;
vm_Cell2w(spTOS,w);
vm_Cell2a_(_sp1,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 1;
{
#line 2510 "./prim"
*a_addr = w;
#line 16171 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
/* ;s ( R:w -- ) */
NAME(";s")
{
Cell w;
vm_Cell2w(rpTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(3);
rp += 1;
{
#line 2510 "./prim"
#ifdef NO_IP

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
IF_rpTOS(rpTOS = rp[0]);

goto *(void *)w;
#else
SET_IP((Xt *)w);
#endif
#line 16210 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
IF_rpTOS(rpTOS = rp[0]);
LABEL2(super18)
NEXT_P2;
}

LABEL(super19)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397823 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 16248 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp1,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
{
#line 2510 "./prim"
w = *a_addr;
#line 16272 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* and ( w1 w2 -- w ) */
NAME("and")
{
Cell w1;
Cell w2;
Cell w;
vm_Cell2w(spTOS,w1);
vm_Cell2w(_sp1,w2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w1=", vm_out); printarg_w(w1);
fputs(" w2=", vm_out); printarg_w(w2);
}
#endif
INC_IP(3);
{
#line 2510 "./prim"
w = w1&w2;
#line 16301 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super19)
NEXT_P2;
}

LABEL(super20)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* = ( n1 n2 -- f ) */
NAME("=")
{
Cell n1;
Cell n2;
Bool f;
vm_Cell2n(sp[1],n1);
vm_Cell2n(spTOS,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
sp += 2;
{
#line 2510 "./prim"
f = FLAG(n1==n2);
#line 1013
#line 16344 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" f=", vm_out); printarg_f(f);
fputc('\n', vm_out);
}
#endif
vm_f2Cell(f,_sp0);
}
/* ?branch ( #a_target f -- ) */
NAME("?branch")
{
Cell * a_target;
Bool f;
vm_Cell2a_(IMM_ARG(IP[1],305397824 ),a_target);
vm_Cell2f(_sp0,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
	#ifdef NO_IP
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);

#line 337
#endif
#line 337
if (f==0) {
#line 337
	#ifdef NO_IP
#line 337
JUMP(a_target);
#line 337
#else
#line 337
SET_IP((Xt *)a_target);
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 337
#endif
#line 337
}
#line 337
SUPER_CONTINUE;
#line 337
#line 16413 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(super20)
NEXT_P2;
}

LABEL(super21)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _IP3;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397825 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 16451 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp0);
}
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IP[2],305397826 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 16473 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* ! ( w a_addr -- ) */
NAME("!")
{
Cell w;
Cell * a_addr;
vm_Cell2w(_sp0,w);
vm_Cell2a_(_sp1,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(4);
{
#line 2510 "./prim"
*a_addr = w;
#line 16500 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
NEXT_P1;
LABEL2(super21)
NEXT_P2;
}

LABEL(super22)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
NEXT_P0;
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
sp += 1;
{
#line 2510 "./prim"
w = *a_addr;
#line 16536 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp0);
}
/* ?branch ( #a_target f -- ) */
NAME("?branch")
{
Cell * a_target;
Bool f;
vm_Cell2a_(IMM_ARG(IP[1],305397827 ),a_target);
vm_Cell2f(_sp0,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
	#ifdef NO_IP
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);

#line 337
#endif
#line 337
if (f==0) {
#line 337
	#ifdef NO_IP
#line 337
JUMP(a_target);
#line 337
#else
#line 337
SET_IP((Xt *)a_target);
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
 NEXT_P2;
#line 337
#endif
#line 337
}
#line 337
SUPER_CONTINUE;
#line 337
#line 16605 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
SUPER_END;
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(super22)
NEXT_P2;
}

LABEL(super23)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* useraddr ( #u -- a_addr ) */
NAME("useraddr")
{
UCell u;
Cell * a_addr;
vm_Cell2u(IMM_ARG(IPTOS,305397828 ),u);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" u=", vm_out); printarg_u(u);
}
#endif
{
#line 2510 "./prim"
a_addr = (Cell *)(up+u);
#line 16643 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" a_addr=", vm_out); printarg_a_(a_addr);
fputc('\n', vm_out);
}
#endif
vm_a_2Cell(a_addr,_sp1);
}
/* ! ( w a_addr -- ) */
NAME("!")
{
Cell w;
Cell * a_addr;
vm_Cell2w(spTOS,w);
vm_Cell2a_(_sp1,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(2);
sp += 1;
{
#line 2510 "./prim"
*a_addr = w;
#line 16672 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
NEXT_P1;
IF_spTOS(spTOS = sp[0]);
LABEL2(super23)
NEXT_P2;
}

LABEL(super24)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* dup ( w -- w w ) */
NAME("dup")
{
Cell w;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 16707 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
vm_w2Cell(w,_sp1);
}
/* ?branch ( #a_target f -- ) */
NAME("?branch")
{
Cell * a_target;
Bool f;
vm_Cell2a_(IMM_ARG(IP[1],305397829 ),a_target);
vm_Cell2f(_sp1,f);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_target=", vm_out); printarg_a_(a_target);
fputs(" f=", vm_out); printarg_f(f);
}
#endif
INC_IP(2);
{
#line 2510 "./prim"
	#ifdef NO_IP
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;

#line 337
#endif
#line 337
if (f==0) {
#line 337
	#ifdef NO_IP
#line 337
JUMP(a_target);
#line 337
#else
#line 337
SET_IP((Xt *)a_target);
#line 337

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
 NEXT_P2;
#line 337
#endif
#line 337
}
#line 337
SUPER_CONTINUE;
#line 337
#line 16774 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
SUPER_END;
NEXT_P1;
LABEL2(super24)
NEXT_P2;
}

LABEL(super25)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _rp0;
NEXT_P0;
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(spTOS,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
{
#line 2510 "./prim"
w = *a_addr;
#line 16810 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
/* ;s ( R:w -- ) */
NAME(";s")
{
Cell w;
vm_Cell2w(rpTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
INC_IP(1);
rp += 1;
{
#line 2510 "./prim"
#ifdef NO_IP

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
SUPER_END;
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);

goto *(void *)w;
#else
SET_IP((Xt *)w);
#endif
#line 16850 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
}
SUPER_END;
NEXT_P1;
IF_rpTOS(rpTOS = rp[0]);
LABEL2(super25)
NEXT_P2;
}

LABEL(super26)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _IP1;
Cell MAYBE_UNUSED _IP2;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* lit ( #w -- w ) */
NAME("lit")
{
Cell w;
vm_Cell2w(IMM_ARG(IPTOS,305397830 ),w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
{
#line 2510 "./prim"
#line 16887 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp1,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
{
#line 2510 "./prim"
w = *a_addr;
#line 16911 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,_sp1);
}
/* + ( n1 n2 -- n ) */
NAME("+")
{
Cell n1;
Cell n2;
Cell n;
vm_Cell2n(spTOS,n1);
vm_Cell2n(_sp1,n2);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" n1=", vm_out); printarg_n(n1);
fputs(" n2=", vm_out); printarg_n(n2);
}
#endif
INC_IP(3);
{
#line 2510 "./prim"
n = n1+n2;
#line 16940 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" n=", vm_out); printarg_n(n);
fputc('\n', vm_out);
}
#endif
vm_n2Cell(n,spTOS);
}
NEXT_P1;
LABEL2(super26)
NEXT_P2;
}

LABEL(super27)
{
DEF_CA
Cell MAYBE_UNUSED _IP0;
Cell MAYBE_UNUSED _sp0;
Cell MAYBE_UNUSED _sp1;
NEXT_P0;
/* dup ( w -- w w ) */
NAME("dup")
{
Cell w;
vm_Cell2w(spTOS,w);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" w=", vm_out); printarg_w(w);
}
#endif
sp += -1;
{
#line 2510 "./prim"
#line 16976 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,sp[1]);
vm_w2Cell(w,_sp1);
}
/* @ ( a_addr -- w ) */
NAME("@")
{
Cell * a_addr;
Cell w;
vm_Cell2a_(_sp1,a_addr);
#ifdef VM_DEBUG
if (vm_debug) {
fputs(" a_addr=", vm_out); printarg_a_(a_addr);
}
#endif
INC_IP(1);
{
#line 2510 "./prim"
w = *a_addr;
#line 17002 "prim.i"
}

#ifdef VM_DEBUG
if (vm_debug) {
fputs(" -- ", vm_out); fputs(" w=", vm_out); printarg_w(w);
fputc('\n', vm_out);
}
#endif
vm_w2Cell(w,spTOS);
}
NEXT_P1;
LABEL2(super27)
NEXT_P2;
}

 #endif
GROUPADD(27)
GROUP( end, 397)
