// File: /workspace/github_c_makefile_star2_O3/RodionGork[P]tinyscheme/scheme.c
// Function: opexe_3
static pointer opexe_3(scheme * sc, enum scheme_opcodes op) {
  pointer x;
  num v;
  int (*comp_func) (num, num) = 0;

  switch (op) {
  case OP_NOT:                 /* not */
    s_retbool(is_false(car(sc->args)));
  case OP_BOOLP:               /* boolean? */
    s_retbool(car(sc->args) == sc->F || car(sc->args) == sc->T);
  case OP_EOFOBJP:             /* boolean? */
    s_retbool(car(sc->args) == sc->EOF_OBJ);
  case OP_NULLP:               /* null? */
    s_retbool(car(sc->args) == sc->NIL);
  case OP_NUMEQ:               /* = */
  case OP_LESS:                /* < */
  case OP_GRE:                 /* > */
  case OP_LEQ:                 /* <= */
  case OP_GEQ:                 /* >= */
    switch (op) {
    case OP_NUMEQ:
      comp_func = num_eq;
      break;
    case OP_LESS:
      comp_func = num_lt;
      break;
    case OP_GRE:
      comp_func = num_gt;
      break;
    case OP_LEQ:
      comp_func = num_le;
      break;
    case OP_GEQ:
      comp_func = num_ge;
      break;
    default:
      break;                    /* Quiet the compiler */
    }
    x = sc->args;
    v = nvalue(car(x));
    x = cdr(x);

    for (; x != sc->NIL; x = cdr(x)) {
      if (!comp_func(v, nvalue(car(x)))) {
        s_retbool(0);
      }
      v = nvalue(car(x));
    }
    s_retbool(1);
  case OP_SYMBOLP:             /* symbol? */
    s_retbool(is_symbol(car(sc->args)));
  case OP_NUMBERP:             /* number? */
    s_retbool(is_number(car(sc->args)));
  case OP_STRINGP:             /* string? */
    s_retbool(is_string(car(sc->args)));
  case OP_INTEGERP:            /* integer? */
    s_retbool(is_integer(car(sc->args)));
  case OP_REALP:               /* real? */
    s_retbool(is_number(car(sc->args)));        /* All numbers are real */
  case OP_CHARP:               /* char? */
    s_retbool(is_character(car(sc->args)));
#if USE_CHAR_CLASSIFIERS
  case OP_CHARAP:              /* char-alphabetic? */
    s_retbool(Cisalpha(ivalue(car(sc->args))));
  case OP_CHARNP:              /* char-numeric? */
    s_retbool(Cisdigit(ivalue(car(sc->args))));
  case OP_CHARWP:              /* char-whitespace? */
    s_retbool(Cisspace(ivalue(car(sc->args))));
  case OP_CHARUP:              /* char-upper-case? */
    s_retbool(Cisupper(ivalue(car(sc->args))));
  case OP_CHARLP:              /* char-lower-case? */
    s_retbool(Cislower(ivalue(car(sc->args))));
#endif
  case OP_PORTP:               /* port? */
    s_retbool(is_port(car(sc->args)));
  case OP_INPORTP:             /* input-port? */
    s_retbool(is_inport(car(sc->args)));
  case OP_OUTPORTP:            /* output-port? */
    s_retbool(is_outport(car(sc->args)));
  case OP_PROCP:               /* procedure? */
          /*--
              * continuation should be procedure by the example
              * (call-with-current-continuation procedure?) ==> #t
                 * in R^3 report sec. 6.9
              */
    s_retbool(is_proc(car(sc->args)) || is_closure(car(sc->args))
        || is_continuation(car(sc->args)) || is_foreign(car(sc->args)));
  case OP_PAIRP:               /* pair? */
    s_retbool(is_pair(car(sc->args)));
  case OP_LISTP:               /* list? */
    s_retbool(list_length(sc, car(sc->args)) >= 0);

  case OP_ENVP:                /* environment? */
    s_retbool(is_environment(car(sc->args)));
  case OP_VECTORP:             /* vector? */
    s_retbool(is_vector(car(sc->args)));
  case OP_BVECTORP:             /* bytevector? */
    s_retbool(is_bvector(car(sc->args)));
  case OP_EQ:                  /* eq? */
    s_retbool(car(sc->args) == cadr(sc->args));
  case OP_EQV:                 /* eqv? */
    s_retbool(eqv(car(sc->args), cadr(sc->args)));
  case OP_CURR_SEC:            /* current-second */
    v.is_fixnum = 0;
    v.value.rvalue = time(0);
    s_return(sc, mk_number(sc, v));
  case OP_EVAL_CNT:            /* eval-count */
    v.is_fixnum = 1;
    v.value.ivalue = evalcnt;
    s_return(sc, mk_number(sc, v));
  default:
    sprintf(sc->strbuff, "%d: illegal operator", sc->op);
    Error_0(sc, sc->strbuff);
  }
  return sc->T;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addl $-0x64, %esi
cmpl $0x20, %esi
ja 0x96f9
leaq 0x3ef1(%rip), %rax      # 0xd1e8
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0x2, %eax
jmp 0x96e6
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0xb, %eax
jmp 0x96e6
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0x0, 0x8(%rax)
je 0x972e
movq 0x10(%rax), %r14
jmp 0x9734
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0x9, %eax
jmp 0x96e6
leaq -0x4582(%rip), %r14     # 0x4de5
jmp 0x94fd
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0x3, %eax
jmp 0x96e6
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0x1, %eax
jmp 0x96e6
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq 0xf0(%rbx), %rax
jmp 0x96e6
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x4e34
shrl $0x1a, %eax
andl $-0x20, %eax
movq 0xb0(%rax,%rbx), %rsi
jmp 0x97dd
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0x5, %eax
jmp 0x96e6
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq 0x90(%rbx), %rax
jmp 0x96e6
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0x0, 0x8(%rax)
je 0x974b
movq 0x10(%rax), %r14
jmp 0x9751
leaq 0x3016(%rip), %r14      # 0xc438
jmp 0x94fd
movq 0x30(%rbx), %rax
movq 0xd0(%rbx), %rsi
cmpq %rsi, 0x8(%rax)
jne 0x97dd
movq 0xb0(%rbx), %rsi
jmp 0x97dd
movq 0x30(%rbx), %rax
movq 0xb0(%rbx), %rcx
movq 0x8(%rax), %rax
movq 0xd0(%rbx), %rdx
cmpq %rcx, %rax
movq %rdx, %rsi
cmoveq %rcx, %rsi
cmpq %rdx, %rax
cmoveq %rcx, %rsi
jmp 0x97dd
xorl %edi, %edi
callq 0x41e0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x90(%rbx), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4689
movl $0x4002, (%rax)         # imm = 0x4002
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movb $0x0, 0x8(%rax)
jmp 0x9610
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0x0, 0x8(%rax)
je 0x9768
movq 0x10(%rax), %r14
jmp 0x976e
leaq 0x2ed2(%rip), %r14      # 0xc3a6
jmp 0x94fd
leaq 0x2f12(%rip), %r14      # 0xc3ef
jmp 0x94fd
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0xa, %eax
jmp 0x96e6
leaq 0x2f86(%rip), %r14      # 0xc483
movq 0x30(%rbx), %rcx
movq 0x10(%rcx), %r15
cmpq 0x90(%rbx), %r15
je 0x943c
movq 0x8(%rcx), %rax
movq 0x10(%rax), %rsi
movq 0x8(%r15), %rdx
movq 0x10(%rdx), %rcx
movl 0x8(%rdx), %edx
movl 0x8(%rax), %edi
callq *%r14
movq %r15, %rcx
testl %eax, %eax
jne 0x9501
movq 0xd0(%rbx), %rsi
jmp 0x97dd
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %edx
andl $0x1f, %edx
movl $0xd0, %eax
cmpl $0xa, %edx
jne 0x97d9
movq 0x8(%rcx), %rcx
xorl %eax, %eax
testb $0x10, (%rcx)
jmp 0x963f
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %eax
andl $0x1f, %eax
cmpl $0x2, %eax
jne 0x95a3
movl $0xb0, %eax
cmpb $0x0, 0x8(%rcx)
jne 0x97d9
movsd 0x10(%rcx), %xmm0
cvttsd2si %xmm0, %rcx
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
jne 0x95a3
jnp 0x97d9
movl $0xd0, %eax
jmp 0x97d9
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0x0, 0x8(%rax)
je 0x9785
movq 0x10(%rax), %r14
jmp 0x978b
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4d0e
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x96e9
movq 0x9bd8(%rip), %r14      # 0x131c8
movq 0x90(%rbx), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4689
movl $0x4002, (%rax)         # imm = 0x4002
movq %r14, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x97e0
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %edx
andl $0x1f, %edx
movl $0xd0, %eax
cmpl $0xa, %edx
jne 0x97d9
movq 0x8(%rcx), %rcx
xorl %eax, %eax
testb $0x20, (%rcx)
sete %al
shll $0x5, %eax
addq $0xb0, %rax
jmp 0x97d9
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
cmpb $0x0, 0x8(%rax)
je 0x97a2
movq 0x10(%rax), %r14
jmp 0x97a8
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
addl $-0x4, %eax
movl $0xd0, %ecx
cmpl $0x4, %eax
ja 0x9692
movl %eax, %eax
leaq 0x3d92(%rip), %rcx      # 0xd420
movq (%rcx,%rax,8), %rcx
movq (%rbx,%rcx), %rsi
jmp 0x97dd
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0xf, %eax
jmp 0x96e6
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
xorl %edx, %edx
cmpq 0x8(%rax), %rcx
setne %dl
shll $0x5, %edx
movq 0xb0(%rdx,%rbx), %rsi
jmp 0x97dd
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
andl $0x1f, %eax
xorl %ecx, %ecx
cmpl $0xe, %eax
setne %cl
shll $0x5, %ecx
movq 0xb0(%rcx,%rbx), %rsi
jmp 0x97dd
movq 0xea0(%rbx), %rdi
movl 0xec8(%rbx), %edx
leaq 0x459f(%rip), %rsi      # 0xdcac
xorl %eax, %eax
callq 0x4290
movq 0xea0(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xad6a
cvttsd2si 0x10(%rax), %r14
callq 0x4300
movq (%rax), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
xorl %edx, %edx
btl $0xb, %eax
jmp 0x97bd
cvttsd2si 0x10(%rax), %r14
callq 0x4300
movq (%rax), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
xorl %edx, %edx
btl $0xa, %eax
jmp 0x97bd
cvttsd2si 0x10(%rax), %r14
callq 0x4300
movq (%rax), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
xorl %edx, %edx
btl $0xd, %eax
jmp 0x97bd
cvttsd2si 0x10(%rax), %r14
callq 0x4300
movq (%rax), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
xorl %edx, %edx
btl $0x8, %eax
jmp 0x97bd
cvttsd2si 0x10(%rax), %r14
callq 0x4300
movq (%rax), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
xorl %edx, %edx
btl $0x9, %eax
setae %dl
shll $0x5, %edx
addq $0xb0, %rdx
testl $0xffffff80, %ecx       # imm = 0xFFFFFF80
movl $0xd0, %eax
cmoveq %rdx, %rax
movq (%rbx,%rax), %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xafff