// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/s7.c
// Function: hash_table_equal_1
static bool hash_table_equal_1(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci, bool equivalent)
                {
                    hash_entry_t **lists;
                    s7_int i, len;
                    shared_info *nci = ci;
                    hash_check_t hf;
                    bool (*eqf)(s7_scheme *sc, s7_pointer x, s7_pointer y, shared_info *ci);

                    if (x == y)
                        return(true);
                    if (!is_hash_table(y))
                    {
                        if (equivalent)
                            check_equivalent_method(sc, y, x);
                        return(false);
                    }
                    if (ci)
                        equal_ref(sc, x, y, ci);

                    if (hash_table_entries(x) != hash_table_entries(y))
                        return(false);
                    if (hash_table_entries(x) == 0)
                        return(true);
                    if ((!equivalent) && ((hash_table_checker_locked(x)) || (hash_table_checker_locked(y))))
                    {
                        if (hash_table_checker(x) != hash_table_checker(y))
                            return(false);
                        if (hash_table_mapper(x) != hash_table_mapper(y))
                            return(false);
                    }

                    len = hash_table_mask(x) + 1;
                    lists = hash_table_elements(x);
                    if (!nci) nci = new_shared_info(sc);

                    if (equivalent)
                        eqf = s7_is_equivalent_1;
                    else eqf = s7_is_equal_1;

                    hf = hash_table_checker(y);
                    if ((hf != hash_equal) && (hf != hash_equivalent))
                    {
                        for (i = 0; i < len; i++)
                        {
                            hash_entry_t *p;
                            for (p = lists[i]; p; p = hash_entry_next(p))
                            {
                                hash_entry_t *y_val;
                                y_val = hf(sc, y, hash_entry_key(p));
                                if (y_val == sc->unentry)
                                    return(false);
                                if (!eqf(sc, hash_entry_value(p), hash_entry_value(y_val), nci))
                                    return(false);
                            }
                        }
                        /* if we get here, every key/value in x has a corresponding key/value in y, and the number of entries match,
                         *   so surely the tables are equal??
                         * if ci not null or hash-table-checker is equal/eqivalent, can't use hf?
                         */
                        return(true);
                    }

                    /* we need to protect the current shared_info data (nci) here so the current hash_table_checker won't work --
                     *   outside equal?/eqivalent? they can safely assume that they can start a new shared_info process.
                     */
                    for (i = 0; i < len; i++)
                    {
                        hash_entry_t *p;
                        for (p = lists[i]; p; p = hash_entry_next(p))
                        {
                            hash_entry_t *x;
                            s7_int hash, loc;
                            s7_pointer key;

                            key = hash_entry_key(p);
                            hash = hash_loc(sc, y, key);
                            loc = hash & hash_table_mask(y);

                            for (x = hash_table_element(y, loc); x; x = hash_entry_next(x))
                                if (hash_entry_raw_hash(x) == hash)
                                    if (eqf(sc, hash_entry_key(x), key, nci))
                                        break;
                            if (!x)
                                return(false);
                            if (!eqf(sc, hash_entry_value(p), hash_entry_value(x), nci))
                                return(false);
                        }
                    }
                    return(true);
                }

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movb %r8b, %al
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movq %rcx, 0xe0(%rsp)
andb $0x1, %al
movb %al, 0xdf(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xf0(%rsp), %rax
cmpq 0xe8(%rsp), %rax
jne 0x1b6c62
movb $0x1, 0x107(%rsp)
jmp 0x1b748c
movq 0xe8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1b, %eax
je 0x1b6e75
testb $0x1, 0xdf(%rsp)
je 0x1b6e68
jmp 0x1b6c86
movq 0xe8(%rsp), %rax
movq (%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x1b6e64
movq 0xf8(%rsp), %rax
testb $0x1, 0x24c(%rax)
je 0x1b6e64
movq 0xf8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xf8(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0x9a10
movq 0x38(%rsp), %rdi
movq %rax, %rsi
movq 0xf8(%rsp), %rax
movq 0x1100(%rax), %rdx
callq 0x98d0
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq 0xf8(%rsp), %rcx
cmpq 0x128(%rcx), %rax
je 0x1b6e62
movq 0xf8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0xf8(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x88(%rsp)
movq 0xf8(%rsp), %rax
movq 0x90(%rax), %rax
movq 0xf8(%rsp), %rcx
cmpq 0x98(%rcx), %rax
ja 0x1b6dae
movq 0xf8(%rsp), %rdi
callq 0xc670
movq 0xf8(%rsp), %rcx
movq 0x90(%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x90(%rcx)
movq -0x8(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq $0x200001, (%rax)       # imm = 0x200001
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x88(%rsp), %rcx
movq 0x98(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x98(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdx
callq 0xd9f0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xda50
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x9be0
andb $0x1, %al
movb %al, 0x107(%rsp)
jmp 0x1b748c
jmp 0x1b6e64
jmp 0x1b6e66
jmp 0x1b6e68
movb $0x0, 0x107(%rsp)
jmp 0x1b748c
cmpq $0x0, 0xe0(%rsp)
je 0x1b7063
jmp 0x1b6e86
movq 0xe8(%rsp), %rax
movq (%rax), %rax
andq $0x20000, %rax          # imm = 0x20000
cmpq $0x0, %rax
je 0x1b6eb8
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0xd28c0
movl %eax, 0xc(%rsp)
jmp 0x1b6ec0
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x1b6ec0
movl 0xc(%rsp), %eax
movl %eax, 0x7c(%rsp)
movq 0xf0(%rsp), %rax
movq (%rax), %rax
andq $0x20000, %rax          # imm = 0x20000
cmpq $0x0, %rax
je 0x1b6f3d
movq 0xe0(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0xd28c0
movl %eax, 0x78(%rsp)
cmpl $0x0, 0x7c(%rsp)
je 0x1b6f18
movl 0x78(%rsp), %eax
cmpl 0x7c(%rsp), %eax
sete %al
andb $0x1, %al
movb %al, 0x107(%rsp)
jmp 0x1b748c
cmpl $0x0, 0x78(%rsp)
je 0x1b6f38
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movl 0x78(%rsp), %edx
callq 0x1b6550
jmp 0x1b705f
cmpl $0x0, 0x7c(%rsp)
je 0x1b6f62
movq 0xe0(%rsp), %rdi
movq 0xf0(%rsp), %rsi
movl 0x7c(%rsp), %edx
callq 0x1b6550
jmp 0x1b705d
movq 0xe0(%rsp), %rax
movl 0xc(%rax), %eax
movq 0xe0(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jl 0x1b6f87
movq 0xe0(%rsp), %rdi
callq 0xd24c0
movq 0xf0(%rsp), %rax
movq (%rax), %rcx
orq $0x20000, %rcx          # imm = 0x20000
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movq (%rax), %rcx
orq $0x20000, %rcx          # imm = 0x20000
movq %rcx, (%rax)
movq 0xf0(%rsp), %rdx
movq 0xe0(%rsp), %rax
movq (%rax), %rax
movq 0xe0(%rsp), %rcx
movslq 0xc(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0xe0(%rsp), %rax
movl 0x10(%rax), %edx
addl $0x1, %edx
movl %edx, 0x10(%rax)
movq 0xe0(%rsp), %rax
movq 0x20(%rax), %rax
movq 0xe0(%rsp), %rsi
movl 0xc(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xc(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq 0xe8(%rsp), %rdx
movq 0xe0(%rsp), %rax
movq (%rax), %rax
movq 0xe0(%rsp), %rcx
movslq 0xc(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0xe0(%rsp), %rax
movl 0x10(%rax), %edx
movq 0xe0(%rsp), %rax
movq 0x20(%rax), %rax
movq 0xe0(%rsp), %rsi
movl 0xc(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xc(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1b705f
jmp 0x1b7061
jmp 0x1b7063
movq 0xf0(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq 0xe8(%rsp), %rcx
movq 0x28(%rcx), %rcx
cmpq 0x18(%rcx), %rax
je 0x1b7092
movb $0x0, 0x107(%rsp)
jmp 0x1b748c
movq 0xf0(%rsp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1b70b2
movb $0x1, 0x107(%rsp)
jmp 0x1b748c
testb $0x1, 0xdf(%rsp)
jne 0x1b7136
movq 0xf0(%rsp), %rax
leaq 0x636d5(%rip), %rcx     # 0x21a7a0
cmpq %rcx, 0x20(%rax)
jne 0x1b70e6
movq 0xe8(%rsp), %rax
leaq 0x636c0(%rip), %rcx     # 0x21a7a0
cmpq %rcx, 0x20(%rax)
je 0x1b7136
movq 0xf0(%rsp), %rax
movq 0x18(%rax), %rax
movq 0xe8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
je 0x1b710d
movb $0x0, 0x107(%rsp)
jmp 0x1b748c
movq 0xf0(%rsp), %rax
movq 0x20(%rax), %rax
movq 0xe8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0x1b7134
movb $0x0, 0x107(%rsp)
jmp 0x1b748c
jmp 0x1b7136
movq 0xf0(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, 0xc0(%rsp)
movq 0xf0(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0xb8(%rsp)
jne 0x1b7182
movq 0xf8(%rsp), %rdi
callq 0xd14f0
movq %rax, 0xb8(%rsp)
testb $0x1, 0xdf(%rsp)
je 0x1b719d
leaq -0x178833(%rip), %rax   # 0x3e960
movq %rax, 0xa8(%rsp)
jmp 0x1b71ac
leaq -0x1788c4(%rip), %rax   # 0x3e8e0
movq %rax, 0xa8(%rsp)
movq 0xe8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0xb0(%rsp)
leaq -0x17f557(%rip), %rax   # 0x37c70
cmpq %rax, 0xb0(%rsp)
je 0x1b72f5
leaq -0xe4a4c(%rip), %rax    # 0xd2790
cmpq %rax, 0xb0(%rsp)
je 0x1b72f5
movq $0x0, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jge 0x1b72e8
movq 0xd0(%rsp), %rax
movq 0xc8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x1b72cd
movq 0xb0(%rsp), %rax
movq 0xf8(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0x70(%rsp), %rcx
movq (%rcx), %rdx
callq *%rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0xf8(%rsp), %rcx
cmpq 0x490(%rcx), %rax
jne 0x1b727b
movb $0x0, 0x107(%rsp)
jmp 0x1b748c
movq 0xa8(%rsp), %rax
movq 0xf8(%rsp), %rdi
movq 0x70(%rsp), %rcx
movq 0x20(%rcx), %rsi
movq 0x68(%rsp), %rcx
movq 0x20(%rcx), %rdx
movq 0xb8(%rsp), %rcx
callq *%rax
testb $0x1, %al
jne 0x1b72b8
movb $0x0, 0x107(%rsp)
jmp 0x1b748c
jmp 0x1b72ba
movq 0x70(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x1b7225
jmp 0x1b72cf
movq 0xc8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc8(%rsp)
jmp 0x1b71f6
movb $0x1, 0x107(%rsp)
jmp 0x1b748c
movq $0x0, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jge 0x1b7484
movq 0xd0(%rsp), %rax
movq 0xc8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x1b7469
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0xe8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x40(%rsp), %rcx
movzbl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0xf8(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq *%rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0xe8(%rsp), %rcx
andq 0x8(%rcx), %rax
movq %rax, 0x48(%rsp)
movq 0xe8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x1b7408
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x50(%rsp), %rax
jne 0x1b73f6
movq 0xa8(%rsp), %rax
movq 0xf8(%rsp), %rdi
movq 0x58(%rsp), %rcx
movq (%rcx), %rsi
movq 0x40(%rsp), %rdx
movq 0xb8(%rsp), %rcx
callq *%rax
testb $0x1, %al
jne 0x1b73f2
jmp 0x1b73f4
jmp 0x1b7408
jmp 0x1b73f6
jmp 0x1b73f8
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x58(%rsp)
jmp 0x1b73ad
cmpq $0x0, 0x58(%rsp)
jne 0x1b741a
movb $0x0, 0x107(%rsp)
jmp 0x1b748c
movq 0xa8(%rsp), %rax
movq 0xf8(%rsp), %rdi
movq 0x60(%rsp), %rcx
movq 0x20(%rcx), %rsi
movq 0x58(%rsp), %rcx
movq 0x20(%rcx), %rdx
movq 0xb8(%rsp), %rcx
callq *%rax
testb $0x1, %al
jne 0x1b7454
movb $0x0, 0x107(%rsp)
jmp 0x1b748c
jmp 0x1b7456
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x60(%rsp)
jmp 0x1b7330
jmp 0x1b746b
movq 0xc8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc8(%rsp)
jmp 0x1b7301
movb $0x1, 0x107(%rsp)
movb 0x107(%rsp), %al
andb $0x1, %al
addq $0x108, %rsp            # imm = 0x108
retq
nopl (%rax)