// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: read_expression
static s7_pointer read_expression(s7_scheme *sc)
                {
                    while (true)
                    {
                        int32_t c;
                        switch (sc->tok)
                        {
                            case TOKEN_EOF:
                                return(eof_object);

                            case TOKEN_BYTE_VECTOR:
                                push_stack_no_let_no_code(sc, OP_READ_BYTE_VECTOR, sc->w);
                                sc->tok = TOKEN_LEFT_PAREN;
                                break;

                            case TOKEN_INT_VECTOR:
                                push_stack_no_let_no_code(sc, OP_READ_INT_VECTOR, sc->w);
                                sc->tok = TOKEN_LEFT_PAREN;
                                break;

                            case TOKEN_FLOAT_VECTOR:
                                push_stack_no_let_no_code(sc, OP_READ_FLOAT_VECTOR, sc->w);
                                sc->tok = TOKEN_LEFT_PAREN;
                                break;

                            case TOKEN_VECTOR:         /* already read #( -- TOKEN_VECTOR is triggered by #( */
                                push_stack_no_let_no_code(sc, OP_READ_VECTOR, sc->w);   /* sc->w is the dimensions */
                                /* fall through */

                            case TOKEN_LEFT_PAREN:
                                sc->tok = token(sc);

                                if (sc->tok == TOKEN_RIGHT_PAREN)
                                    return(sc->nil);

                                if (sc->tok == TOKEN_DOT)
                                {
                                    back_up_stack(sc);
                                    do {c = inchar(sc->input_port);} while ((c != ')') && (c != EOF));
                                    return(read_error(sc, "stray dot after '('?"));         /* (car '( . )) */
                                }

                                if (sc->tok == TOKEN_EOF)
                                    return(missing_close_paren_error(sc));

                                push_stack_no_let_no_code(sc, OP_READ_LIST, sc->nil);
                                /* here we need to clear args, but code is ignored */

                                check_stack_size(sc);
                                break;

                            case TOKEN_QUOTE:
                                push_stack_no_let_no_code(sc, OP_READ_QUOTE, sc->nil);
                                sc->tok = token(sc);
                                break;

                            case TOKEN_BACK_QUOTE:
                                sc->tok = token(sc);
                                push_stack_no_let_no_code(sc, OP_READ_QUASIQUOTE, sc->nil);
                                break;

                            case TOKEN_COMMA:
                                push_stack_no_let_no_code(sc, OP_READ_UNQUOTE, sc->nil);
                                sc->tok = token(sc);
                                switch (sc->tok)
                                {
                                    case TOKEN_EOF:
                                        pop_stack(sc);
                                        return(read_error(sc, "stray comma at the end of the input?"));

                                    case TOKEN_RIGHT_PAREN:
                                        return(read_expression_read_error(sc));

                                    default:
                                        break;
                                }
                                break;

                            case TOKEN_AT_MARK:
                                push_stack_no_let_no_code(sc, OP_READ_APPLY_VALUES, sc->nil);
                                sc->tok = token(sc);
                                break;

                            case TOKEN_ATOM:
                                return(port_read_name(sc->input_port)(sc, sc->input_port));
                                /* If reading list (from lparen), this will finally get us to op_read_list */

                            case TOKEN_DOUBLE_QUOTE:
                                read_double_quote(sc);
                                return(sc->value);

                            case TOKEN_SHARP_CONST:
                                return(port_read_sharp(sc->input_port)(sc, sc->input_port));

                            case TOKEN_DOT:                                             /* (catch #t (lambda () (+ 1 . . )) (lambda args 'hiho)) */
                                back_up_stack(sc);
                                do {c = inchar(sc->input_port);} while ((c != ')') && (c != EOF));
                                return(read_error(sc, "stray dot in list?"));             /* (+ 1 . . ) */

                            case TOKEN_RIGHT_PAREN:                                     /* (catch #t (lambda () '(1 2 . )) (lambda args 'hiho)) */
                                back_up_stack(sc);
                                return(read_error(sc, "unexpected close paren"));         /* (+ 1 2)) or (+ 1 . ) */
                        }
                    }
                    /* we never get here */
                    return(sc->nil);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x33704(%rip), %r14     # 0xd49ac
movl 0x30(%rbx), %eax
cmpq $0xe, %rax
ja 0xa12a8
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1d4, 0x18(%rax)      # imm = 0x1D4
jmp 0xa1406
movq %rbx, %rdi
callq 0x7456a
movl %eax, 0x30(%rbx)
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1d5, 0x18(%rax)      # imm = 0x1D5
addq $0x20, 0x50(%rbx)
jmp 0xa12a8
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1d6, 0x18(%rax)      # imm = 0x1D6
addq $0x20, 0x50(%rbx)
movq %rbx, %rdi
callq 0x7456a
movl %eax, 0x30(%rbx)
cmpl $0x2, %eax
je 0xa1577
testl %eax, %eax
jne 0xa12a8
jmp 0xa1550
movq 0x4d8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1db, 0x18(%rax)      # imm = 0x1DB
jmp 0xa1453
movq 0x4d8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1d8, 0x18(%rax)      # imm = 0x1D8
addq $0x20, 0x50(%rbx)
movq %rbx, %rdi
callq 0x7456a
movl %eax, 0x30(%rbx)
testl %eax, %eax
je 0xa1470
cmpl $0x3, %eax
je 0xa1486
cmpl $0x2, %eax
je 0xa1464
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1d1, 0x18(%rax)      # imm = 0x1D1
movq 0x50(%rbx), %rax
addq $0x20, %rax
movq %rax, 0x50(%rbx)
cmpq 0x58(%rbx), %rax
jb 0xa12a8
movq %rbx, %rdi
callq 0x91caf
jmp 0xa12a8
movq 0x50(%rbx), %rax
movq 0x110(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rbx), %rax
movq $0x1d7, 0x18(%rax)      # imm = 0x1D7
addq $0x20, 0x50(%rbx)
movq %rbx, %rdi
callq 0x7456a
movl %eax, 0x30(%rbx)
jmp 0xa12a8
movq 0x4d8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1da, 0x18(%rax)      # imm = 0x1DA
jmp 0xa1453
movq 0x4d8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1d9, 0x18(%rax)      # imm = 0x1D9
addq $0x20, 0x50(%rbx)
movl $0x1, 0x30(%rbx)
jmp 0xa12a8
movq 0x110(%rbx), %r14
jmp 0xa153e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa0ed5
movq %rbx, %rdi
callq 0xb8efa
movq 0x170(%rbx), %rdi
callq 0x74d4a
cmpl $0x29, %eax
je 0xa14a4
cmpl $-0x1, %eax
jne 0xa148e
leaq 0x423cb(%rip), %rsi     # 0xe3876
jmp 0xa166d
movq %rbx, %rdi
callq 0xb8efa
leaq 0x423e9(%rip), %rsi     # 0xe38a8
jmp 0xa166d
movq %rbx, %rdi
callq 0xb8efa
movq 0x170(%rbx), %rdi
callq 0x74d4a
cmpl $0x29, %eax
je 0xa14e2
cmpl $-0x1, %eax
jne 0xa14cc
leaq 0x4414a(%rip), %rsi     # 0xe5633
jmp 0xa166d
movq 0x7426b(%rip), %r14     # 0x115760
jmp 0xa153e
movq 0x170(%rbx), %rsi
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq 0x28(%rax), %rax
jmp 0xa151f
movq 0x170(%rbx), %rsi
movq 0x8(%rsi), %rax
movq 0x48(%rax), %rax
movq 0x30(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rbx, %rdi
callq 0xa1683
movq 0x20(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x50(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
leaq 0x4409c(%rip), %rsi     # 0xe560e
jmp 0xa166d
movq 0x50(%rbx), %rax
movq 0x170(%rbx), %r12
leaq -0x20(%rax), %rcx
movq %rcx, 0x50(%rbx)
movups -0x20(%rax), %xmm0
movups -0x10(%rax), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpb $0x23, (%r12)
jne 0xa1666
movq 0x8(%r12), %rax
cmpb $0x0, 0x2(%rax)
jne 0xa1666
cmpq $0x0, 0x10(%r12)
je 0xa1666
movq 0x20(%r12), %r13
testq %r13, %r13
jle 0xa1666
cmpq $0x29, %r13
pushq $0x28
popq %rbp
cmovaeq %r13, %rbp
leaq -0x28(%rbp), %r14
movl $0x80, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xd239
movq %rax, (%rsp)
movq 0x10(%rax), %r15
movl $0x22207461, (%r15)     # imm = 0x22207461
movl $0x2e2e2e22, 0x3(%r15)  # imm = 0x2E2E2E22
leaq 0x7(%r15), %rdi
movq %r13, %rdx
subq %r14, %rdx
addq 0x10(%r12), %r14
movq %r14, %rsi
callq 0x83e0
leaq (%r15,%r13), %rax
addq $0x7, %rax
subq %rbp, %rax
movw $0x2e2e, 0x28(%rax)     # imm = 0x2E2E
movb $0x2e, 0x2a(%rax)
subq %rbp, %r13
addq $0x32, %r13
movq (%rsp), %rcx
movq %r13, 0x8(%rcx)
movq 0x1908(%rbx), %r14
movq 0x6d8(%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0x6d8(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2cdc0
jmp 0xa153e
leaq 0x43fe1(%rip), %rsi     # 0xe564e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7da56