LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp.c
// Function: probe_setup
void
probe_setup()
{
	int i;

	if (fd4 < 0) {
		errno = fd4errno;
		perror("socket (IPv4)");
		exit(1);
	}
	if (fd6 < 0) {
		errno = fd6errno;
		perror("socket (IPv6)");
		exit(1);
	}

	/* Prepare datapacket */
	ident = getpid() & 0xffff;
	for (i=0; i<datalen; i++) {
		outpacket[ICMP_MINLEN + i] = '0' + i;
		outpacket6[ICMP6_MINLEN + i] = '0' + i;
	}

	evutil_make_socket_nonblocking(fd4);
	ev_read4 = event_new(ev_base, fd4, EV_READ|EV_PERSIST, read_packet4, NULL);
	event_add(ev_read4, NULL);
	evutil_make_socket_nonblocking(fd6);
	ev_read6 = event_new(ev_base, fd6, EV_READ|EV_PERSIST, read_packet6, NULL);
	event_add(ev_read6, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x4848(%rip), %rbx      # 0x8230
cmpl $0x0, (%rbx)
js 0x3aab
leaq 0x4840(%rip), %r14      # 0x8238
cmpl $0x0, (%r14)
js 0x3ac4
callq 0x22a0
movzwl %ax, %eax
movl %eax, 0x4858(%rip)      # 0x8268
movslq 0x47d1(%rip), %rax      # 0x81e8
xorl %ecx, %ecx
leaq 0x4850(%rip), %rdx      # 0x8270
leaq 0x14849(%rip), %rsi     # 0x18270
cmpq %rax, %rcx
jge 0x3a3e
leal 0x30(%rcx), %edi
movb %dil, 0x8(%rcx,%rdx)
movb %dil, 0x8(%rcx,%rsi)
incq %rcx
jmp 0x3a27
movl (%rbx), %edi
callq 0x2280
leaq 0x47dc(%rip), %r15      # 0x8228
movq (%r15), %rdi
movl (%rbx), %esi
leaq 0x90(%rip), %rcx        # 0x3ae8
pushq $0x12
popq %rbx
movl %ebx, %edx
xorl %r8d, %r8d
callq 0x2160
movq %rax, 0x24804(%rip)     # 0x28270
movq %rax, %rdi
xorl %esi, %esi
callq 0x20b0
movl (%r14), %edi
callq 0x2280
movq (%r15), %rdi
movl (%r14), %esi
leaq 0x155(%rip), %rcx       # 0x3be0
movl %ebx, %edx
xorl %r8d, %r8d
callq 0x2160
movq %rax, 0x247dc(%rip)     # 0x28278
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x20b0
leaq 0x4782(%rip), %rax      # 0x8234
movl (%rax), %ebx
callq 0x2040
movl %ebx, (%rax)
leaq 0x1642(%rip), %rdi      # 0x5104
jmp 0x3adb
leaq 0x4771(%rip), %rax      # 0x823c
movl (%rax), %ebx
callq 0x2040
movl %ebx, (%rax)
leaq 0x1637(%rip), %rdi      # 0x5112
callq 0x2150
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp.c
// Function: read_packet4
static void
read_packet4(int fd, short what, void *thunk)
{
	char inpacket[IP_MAXPACKET];
	struct sockaddr_in sin;
	struct ip *ip;
	struct ip *oip;
	struct icmp *icp;
	struct icmp *oicp;
	socklen_t salen;
	int hlen;
	int seq;
	int n;

	salen = sizeof(sin);
	memset(inpacket, 0, sizeof(inpacket));
	n = recvfrom(fd, inpacket, sizeof(inpacket), 0,
	    (struct sockaddr *)&sin, &salen);
	if (n < 0) {
		return;
	}

	ip = (struct ip *)inpacket;
	hlen = ip->ip_hl << 2;
	if (ip->ip_p != IPPROTO_ICMP) {
		return;
	}
	if (n < hlen + ICMP_MINLEN) {
		return;
	}

	icp = (struct icmp *)(inpacket + hlen);
	if (icp->icmp_type == ICMP_ECHOREPLY) {
		if (icp->icmp_id != htons(ident))
			return; /*  skip other ping sessions */

		seq = ntohs(icp->icmp_seq);
		find_marktarget(AF_INET, &sin.sin_addr, seq, '.');
	} else {
		/* Skip short icmp error packets. */
		if (n < ICMP_MINLEN * 2 + sizeof(struct ip))
			return;

		/* Check aspects of the original packet */
		oip = (struct ip *)icp->icmp_data;
		oicp = (struct icmp *)(oip + 1);
		if (oip->ip_p != IPPROTO_ICMP)
			return;
		if (oicp->icmp_type != ICMP_ECHO)
			return;
		if (oicp->icmp_id != htons(ident))
			return;

		seq = ntohs(oicp->icmp_seq);
		if (icp->icmp_type == ICMP_UNREACH)
			find_marktarget(AF_INET, &oip->ip_dst, seq, '#');
		else
			find_marktarget(AF_INET, &oip->ip_dst, seq, '%');
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10020, %rsp          # imm = 0x10020
movl %edi, %ebx
leaq 0xc(%rsp), %r14
movl $0x10, (%r14)
leaq 0x20(%rsp), %r15
movl $0xffff, %edx           # imm = 0xFFFF
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
leaq 0x10(%rsp), %r8
movl $0xffff, %edx           # imm = 0xFFFF
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x2120
testl %eax, %eax
js 0x3bcf
cmpb $0x1, 0x29(%rsp)
jne 0x3bcf
movl 0x20(%rsp), %ecx
shll $0x2, %ecx
andl $0x3c, %ecx
leal 0x8(%rcx), %edx
cmpl %eax, %edx
ja 0x3bcf
leaq (%rsp,%rcx), %rsi
addq $0x20, %rsi
movb (%rsi), %cl
testb %cl, %cl
je 0x3ba3
andl $0x7ffffffc, %eax       # imm = 0x7FFFFFFC
cmpl $0x24, %eax
jb 0x3bcf
cmpb $0x1, 0x11(%rsi)
jne 0x3bcf
cmpb $0x8, 0x1c(%rsi)
jne 0x3bcf
movzwl 0x46ea(%rip), %eax      # 0x8268
rolw $0x8, %ax
cmpw %ax, 0x20(%rsi)
jne 0x3bcf
movzwl 0x22(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
addq $0x18, %rsi
pushq $0x2
popq %rdi
cmpb $0x3, %cl
jne 0x3bdc
pushq $0x23
jmp 0x3bc9
movzwl 0x46be(%rip), %eax      # 0x8268
rolw $0x8, %ax
cmpw %ax, 0x4(%rsi)
jne 0x3bcf
movzwl 0x6(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
leaq 0x14(%rsp), %rsi
pushq $0x2
popq %rdi
pushq $0x2e
popq %rcx
callq 0x3fbb
addq $0x10020, %rsp          # imm = 0x10020
popq %rbx
popq %r14
popq %r15
retq
pushq $0x25
jmp 0x3bc9
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp.c
// Function: read_packet6
static void
read_packet6(int fd, short what, void *thunk)
{
	char inpacket[IP_MAXPACKET];
	struct sockaddr_in6 sin6;
	struct ip6_hdr *oip6;
	struct icmp6_hdr *icmp6h;
	struct icmp6_hdr *oicmp6h;
	socklen_t salen;
	int seq;
	int n;

	salen = sizeof(sin6);
	memset(inpacket, 0, sizeof(inpacket));
	n = recvfrom(fd, inpacket, sizeof(inpacket), 0,
	    (struct sockaddr *)&sin6, &salen);
	if (n < 0) {
		return;
	}
	if (n < ICMP6_MINLEN) {
		return;
	}

	/* SOCK_RAW for IPPROTO_ICMPV6 doesn't include IPv6 header */
	icmp6h = (struct icmp6_hdr *)(inpacket);
	if (icmp6h->icmp6_type == ICMP6_ECHO_REPLY) {
		if (icmp6h->icmp6_id != htons(ident))
			return; /*  skip other ping sessions */
		if (n != sizeof(struct icmp6_hdr) + datalen)
			return;

		seq = ntohs(icmp6h->icmp6_seq);
		find_marktarget(AF_INET6, &sin6.sin6_addr, seq, '.');
	} else {
		/* Skip short icmp error packets. */
		if (n < ICMP6_MINLEN * 2 + sizeof(struct ip6_hdr))
			return;

		/* Check aspects of the original packet */
		oip6 = (struct ip6_hdr *)(icmp6h + 1);
		oicmp6h = (struct icmp6_hdr *)(oip6 + 1);
		if (oip6->ip6_nxt != IPPROTO_ICMPV6)
			return;
		if (oicmp6h->icmp6_type != ICMP6_ECHO_REQUEST)
			return;
		if (oicmp6h->icmp6_id != htons(ident))
			return;

		seq = ntohs(oicmp6h->icmp6_seq);
		if (icmp6h->icmp6_type == ICMP6_DST_UNREACH)
			find_marktarget(AF_INET6, &oip6->ip6_dst, seq, '#');
		else
			find_marktarget(AF_INET6, &oip6->ip6_dst, seq, '%');
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10020, %rsp          # imm = 0x10020
movl %edi, %ebx
movq %rsp, %r14
movl $0x1c, (%r14)
leaq 0x20(%rsp), %r15
movl $0xffff, %edx           # imm = 0xFFFF
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
leaq 0x4(%rsp), %r8
movl $0xffff, %edx           # imm = 0xFFFF
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x2120
testl %eax, %eax
js 0x3c34
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq $0x8, %rax
jae 0x3c41
addq $0x10020, %rsp          # imm = 0x10020
popq %rbx
popq %r14
popq %r15
retq
movb 0x20(%rsp), %cl
cmpb $-0x7f, %cl
jne 0x3c84
movzwl 0x4617(%rip), %ecx      # 0x8268
rolw $0x8, %cx
cmpw %cx, 0x24(%rsp)
jne 0x3c34
movslq 0x4585(%rip), %rcx      # 0x81e8
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x3c34
movzwl 0x26(%rsp), %eax
rolw $0x8, %ax
movzwl %ax, %edx
leaq 0xc(%rsp), %rsi
pushq $0xa
popq %rdi
pushq $0x2e
jmp 0x3cc8
cmpl $0x38, %eax
jb 0x3c34
cmpb $0x3a, 0x2e(%rsp)
jne 0x3c34
movb 0x50(%rsp), %al
negb %al
jno 0x3c34
movzwl 0x45c9(%rip), %eax      # 0x8268
rolw $0x8, %ax
cmpw %ax, 0x54(%rsp)
jne 0x3c34
leaq 0x40(%rsp), %rsi
movzwl 0x16(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
pushq $0xa
popq %rdi
cmpb $0x1, %cl
jne 0x3cc6
pushq $0x23
jmp 0x3cc8
pushq $0x25
popq %rcx
callq 0x3fbb
jmp 0x3c34
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp.c
// Function: probe_cleanup
void
probe_cleanup()
{

	HASH_CLEAR(hh, hash);
	if (ev_read4)
		event_free(ev_read4);
	if (ev_read6)
		event_free(ev_read6);
}

// Assembly:
pushq %rax
movq 0x4585(%rip), %rax      # 0x8260
testq %rax, %rax
je 0x3d04
movq 0x70(%rax), %rax
movq (%rax), %rdi
callq 0x21d0
movq 0x456d(%rip), %rax      # 0x8260
movq 0x70(%rax), %rdi
callq 0x21d0
andq $0x0, 0x455c(%rip)      # 0x8260
movq 0x24565(%rip), %rdi     # 0x28270
testq %rdi, %rdi
je 0x3d15
callq 0x2300
movq 0x2455c(%rip), %rdi     # 0x28278
testq %rdi, %rdi
je 0x3d27
popq %rax
jmp 0x2300
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp.c
// Function: probe_new
struct probe *
probe_new(const char *line, void *owner)
{
	union addr sa;
	struct probe *prb;
	int salen;

	prb = calloc(1, sizeof(*prb));
	if (prb == NULL) {
		perror("malloc");
		return (prb);
	}
	prb->owner = owner;
	strncat(prb->host, line, sizeof(prb->host) - 1);

	salen = sizeof(sa);
	if (evutil_parse_sockaddr_port(prb->host, &sa.sa, &salen) == 0) {
		sa(prb)->sa_family = sa.sa.sa_family;
		if (sa.sa.sa_family == AF_INET6) {
			memcpy(&sin6(prb)->sin6_addr, &sa.sin6.sin6_addr,
			    sizeof(sin6(prb)->sin6_addr));
		} else {
			memcpy(&sin(prb)->sin_addr, &sa.sin.sin_addr,
			    sizeof(sin(prb)->sin_addr));
		}
		prb->resolved = 1;
		activate(prb);
	} else {
		prb->dnstask = dnstask_new(prb->host, resolved, prb);
		if (prb->dnstask == NULL) {
			free(prb);
			return NULL;
		}
	}
	return (prb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rdi
movl $0xb8, %esi
callq 0x2100
testq %rax, %rax
je 0x3dda
movq %rax, %rbx
movq %r15, 0xb0(%rax)
pushq $0x3f
popq %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2110
movq %rsp, %rdx
movl $0x1c, (%rdx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x3da8
leaq 0x6e(%rip), %rsi        # 0x3df5
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x48c0
movq %rax, 0xa8(%rbx)
testq %rax, %rax
jne 0x3de8
movq %rbx, %rdi
callq 0x21d0
jmp 0x3de6
movzwl 0x4(%rsp), %eax
movw %ax, 0x44(%rbx)
cmpw $0xa, %ax
jne 0x3dc2
movups 0xc(%rsp), %xmm0
movups %xmm0, 0x4c(%rbx)
jmp 0x3dc9
movl 0x8(%rsp), %eax
movl %eax, 0x48(%rbx)
movl $0x1, 0x40(%rbx)
movq %rbx, %rdi
callq 0x2d60
jmp 0x3de8
leaq 0x130d(%rip), %rdi      # 0x50ee
callq 0x2150
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp.c
// Function: probe_free
void
probe_free(struct probe *prb)
{

	if (prb->dnstask)
		dnstask_free(prb->dnstask);
	deactivate(prb);
	free(prb);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
testq %rdi, %rdi
je 0x3e76
callq 0x49bc
movq %rbx, %rdi
callq 0x33d3
movq %rbx, %rdi
popq %rbx
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp.c
// Function: probe_send
void
probe_send(struct probe *prb, int seq)
{
	int len;
	int n;

	prb->last_seq = seq;
	if (!prb->resolved) {
		target_mark(prb->owner, seq, '@');
		return;
	}

	if (prb->duplicate) {
		target_mark(prb->owner, seq, '"'); /* transmit error */
		return;
	}

	if (sa(prb)->sa_family == AF_INET6) {
		n = write_packet6(sa(prb), seq & 0xffff);
		len = ICMP6_MINLEN + datalen;
	} else {
		n = write_packet4(sa(prb), seq & 0xffff);
		len = ICMP_MINLEN + datalen;
	}

	if (n < 0) {
		target_mark(prb->owner, seq, '!'); /* transmit error */
	} else if (n != len) {
		target_mark(prb->owner, seq, '$'); /* partial transmit */
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x68(%rdi)
cmpl $0x0, 0x40(%rdi)
je 0x3ea4
cmpq $0x0, 0x60(%r14)
je 0x3ebc
pushq $0x22
jmp 0x3ea6
pushq $0x40
popq %rdx
movq 0xb0(%r14), %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2490
leaq 0x44(%r14), %r8
movl 0x4322(%rip), %eax      # 0x81e8
addl $0x8, %eax
movl %ebx, %ecx
rolw $0x8, %cx
cmpw $0xa, 0x44(%r14)
jne 0x3f11
movl $0x80, 0x1438f(%rip)    # 0x18270
leaq 0x14388(%rip), %rsi     # 0x18270
movw %cx, 0x14387(%rip)      # 0x18276
movzwl 0x4372(%rip), %ecx      # 0x8268
rolw $0x8, %cx
movw %cx, 0x14373(%rip)      # 0x18274
leaq 0x4330(%rip), %rcx      # 0x8238
movl (%rcx), %edi
movslq %eax, %rdx
pushq $0x1c
jmp 0x3f8b
movl $0x8, 0x4355(%rip)      # 0x8270
leaq 0x434e(%rip), %rdx      # 0x8270
movzwl 0x433f(%rip), %esi      # 0x8268
rolw $0x8, %si
movw %cx, 0x4342(%rip)       # 0x8276
movw %si, 0x4339(%rip)       # 0x8274
xorl %ecx, %ecx
movl %eax, %esi
cmpl $0x2, %esi
jl 0x3f52
movzwl (%rdx), %edi
addq $0x2, %rdx
addl %edi, %ecx
addl $-0x2, %esi
jmp 0x3f3f
cmpl $0x1, %esi
jne 0x3f5c
movzbl (%rdx), %edx
addl %edx, %ecx
movl %ecx, %edx
sarl $0x10, %edx
movzwl %cx, %ecx
addl %edx, %ecx
movl %ecx, %edx
shrl $0x10, %edx
addl %ecx, %edx
notl %edx
movw %dx, 0x42fc(%rip)       # 0x8272
leaq 0x42f3(%rip), %rsi      # 0x8270
leaq 0x42ac(%rip), %rcx      # 0x8230
movl (%rcx), %edi
movslq %eax, %rdx
pushq $0x10
popq %r9
xorl %ecx, %ecx
callq 0x2050
testl %eax, %eax
js 0x3fad
movl 0x424a(%rip), %ecx      # 0x81e8
addl $0x8, %ecx
cmpl %eax, %ecx
jne 0x3fb4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x21
jmp 0x3ea6
pushq $0x24
jmp 0x3ea6
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp.c
// Function: find_marktarget
static void
find_marktarget(int af, void *address, int seq, int ch)
{
	struct probe *prb;
	int npkts;

	prb = find(af, address);
	if (prb == NULL)
		return; /* unknown source address */
	npkts = prb->last_seq;
	if ((npkts & 0xffff) < seq)
	    npkts -= 1<<16;
	target_mark(prb->owner, (npkts & ~0xffff) | seq, ch);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
callq 0x376b
testq %rax, %rax
je 0x3ffa
movl 0x68(%rax), %ecx
movzwl %cx, %edx
movl $0xffff0000, %r8d       # imm = 0xFFFF0000
leal (%rcx,%r8), %esi
cmpl %ebp, %edx
cmovgel %ecx, %esi
movq 0xb0(%rax), %rdi
andl %r8d, %esi
orl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2490
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: find_method
static s7_pointer find_method(s7_scheme *sc, s7_pointer env, s7_pointer symbol)
    {
        s7_pointer x;
        if (symbol_id(symbol) == 0) /* this means the symbol has never been used locally, so how can it be a method? */
            return(sc->undefined);

        if (let_id(env) == symbol_id(symbol))
            return(slot_value(local_slot(symbol)));

        for (x = env; symbol_id(symbol) < let_id(x); x = outlet(x));

        if (let_id(x) == symbol_id(symbol))
            return(slot_value(local_slot(symbol)));

        for (; is_let(x); x = outlet(x))
        {
            s7_pointer y;
            for (y = let_slots(x); tis_slot(y); y = next_slot(y))
                if (slot_symbol(y) == symbol)
                    return(slot_value(y));
        }
        return(sc->undefined);
    }

// Assembly:
movq 0x20(%rdx), %rax
testq %rax, %rax
je 0x88df
movq 0x18(%rsi), %rcx
cmpq %rax, %rcx
je 0x88b2
cmpq %rcx, %rax
jge 0x88b0
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %rcx
jmp 0x88a1
jne 0x88bc
movq 0x18(%rdx), %rdi
addq $0x10, %rdi
jmp 0x88ef
cmpb $0x1c, (%rsi)
jne 0x88df
leaq 0x8(%rsi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x88d9
cmpq %rdx, 0x8(%rax)
je 0x88e8
addq $0x18, %rax
jmp 0x88c5
movq 0x10(%rsi), %rsi
jmp 0x88bc
addq $0x128, %rdi            # imm = 0x128
jmp 0x88ef
addq $0x10, %rax
movq %rax, %rdi
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: find_let
static s7_pointer find_let(s7_scheme *sc, s7_pointer obj)
    {
        if (is_let(obj)) return(obj);
        switch (type(obj))
        {
            case T_MACRO:   case T_MACRO_STAR:
            case T_BACRO:   case T_BACRO_STAR:
            case T_CLOSURE: case T_CLOSURE_STAR:
                return(closure_let(obj));

            case T_C_OBJECT:
                return(c_object_let(obj));

            case T_C_POINTER:
                if ((is_let(c_pointer_info(obj))) &&
                        (c_pointer_info(obj) != sc->rootlet))
                    return(c_pointer_info(obj));
        }
        return(sc->nil);
    }

// Assembly:
movq %rsi, %rax
movzbl (%rsi), %ecx
leal -0x28(%rcx), %edx
cmpl $0x6, %edx
jae 0x890c
addq $0x18, %rax
movq %rax, %rdi
movq (%rdi), %rax
retq
cmpl $0x14, %ecx
je 0x8901
cmpl $0x1c, %ecx
je 0x890b
cmpl $0x21, %ecx
jne 0x892d
movq 0x18(%rax), %rax
cmpb $0x1c, (%rax)
jne 0x892d
cmpq 0x150(%rdi), %rax
jne 0x890b
addq $0x110, %rdi            # imm = 0x110
jmp 0x8908
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_protect
s7_inline s7_int s7_gc_protect(s7_scheme *sc, s7_pointer x)
    {
        s7_int loc;
        if (sc->gpofl_loc < 0)
            resize_gc_protect(sc);
        loc = sc->gpofl[sc->gpofl_loc--];
        vector_element(sc->protected_objects, loc) = x;
        return(loc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x108(%rdi), %rcx
testq %rcx, %rcx
js 0x89d0
movq 0xe8(%r14), %rax
jmp 0x8a83
movq 0xd0(%r14), %rax
movq 0xf0(%r14), %r12
leaq (%r12,%r12), %r13
movq 0x18(%rax), %rsi
movq %r12, %r15
shlq $0x4, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x9859
andq $0x0, 0x20(%rax)
movq 0xd0(%r14), %rcx
movq %rax, 0x18(%rcx)
movq (%rax), %rax
movq 0xd0(%r14), %rcx
movq %rax, 0x10(%rcx)
movq 0xd0(%r14), %rax
movq %r13, 0x8(%rax)
movq %r13, 0xf0(%r14)
movq 0xe8(%r14), %rdi
movq %r15, %rsi
callq 0x8510
movq %rax, 0xe8(%r14)
cmpq %r13, %r12
jge 0x8a7c
movq 0xd0(%r14), %rax
movq 0x140(%r14), %rcx
movq 0x10(%rax), %rax
movq %rcx, (%rax,%r12,8)
movq 0xe8(%r14), %rax
movq 0x108(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x108(%r14)
movq %r12, 0x8(%rax,%rcx,8)
incq %r12
jmp 0x8a3e
movq 0x108(%r14), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0x108(%r14)
movq (%rax,%rcx,8), %rax
movq 0xd0(%r14), %rcx
movq 0x10(%rcx), %rcx
movq %rbx, (%rcx,%rax,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_unprotect
void s7_gc_unprotect(s7_scheme *sc, s7_pointer x)
    {
        s7_int i;
        for (i = 0; i < sc->protected_objects_size; i++)
            if (vector_element(sc->protected_objects, i) == x)
            {
                vector_element(sc->protected_objects, i) = sc->unused;
                sc->gpofl[++sc->gpofl_loc] = i;
                return;
            }
    }

// Assembly:
movq 0xf0(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
cmpq %rax, %rcx
je 0x8aff
movq 0xd0(%rdi), %rdx
movq 0x10(%rdx), %rdx
cmpq %rsi, (%rdx,%rax,8)
je 0x8ad6
incq %rax
jmp 0x8abb
movq 0x140(%rdi), %rcx
movq %rcx, (%rdx,%rax,8)
movq 0xe8(%rdi), %rcx
movq 0x108(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x108(%rdi)
movq %rax, 0x8(%rcx,%rdx,8)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_unprotect_at
void s7_gc_unprotect_at(s7_scheme *sc, s7_int loc)
    {
        if (loc < sc->protected_objects_size)
        {
            if (vector_element(sc->protected_objects, loc) != sc->unused)
                sc->gpofl[++sc->gpofl_loc] = loc;
            vector_element(sc->protected_objects, loc) = sc->unused;
        }
    }

// Assembly:
cmpq %rsi, 0xf0(%rdi)
jle 0x8b47
movq 0xd0(%rdi), %rcx
movq 0x140(%rdi), %rax
movq 0x10(%rcx), %rdx
cmpq %rax, (%rdx,%rsi,8)
je 0x8b43
movq 0xe8(%rdi), %rdx
movq 0x108(%rdi), %r8
leaq 0x1(%r8), %r9
movq %r9, 0x108(%rdi)
movq %rsi, 0x8(%rdx,%r8,8)
movq 0x10(%rcx), %rdx
movq %rax, (%rdx,%rsi,8)
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_gc_protected_at
s7_pointer s7_gc_protected_at(s7_scheme *sc, s7_int loc)
    {
        s7_pointer obj;

        obj = sc->unspecified;
        if (loc < sc->protected_objects_size)
            obj = vector_element(sc->protected_objects, loc);
        if (obj == sc->unused)
            return(sc->unspecified);

        return(obj);
    }

// Assembly:
leaq 0x130(%rdi), %rcx
movq %rcx, %rax
cmpq %rsi, 0xf0(%rdi)
jle 0x8b6d
movq 0xd0(%rdi), %rax
shlq $0x3, %rsi
addq 0x10(%rax), %rsi
movq %rsi, %rax
movq (%rax), %rax
cmpq 0x140(%rdi), %rax
je 0x8b7a
retq
movq (%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_symbol_with_length
static inline s7_pointer make_symbol_with_length(s7_scheme *sc, const char *name, s7_int len)
    {
        s7_pointer x;
        uint64_t hash;
        uint32_t location;

        hash = raw_string_hash((const uint8_t *)name, len);
        location = hash % SYMBOL_TABLE_SIZE;

        if (len <= 8)
        {
            for (x = vector_element(sc->symbol_table, location); is_pair(x); x = cdr(x))
                if ((hash == pair_raw_hash(x)) &&
                        (len == pair_raw_len(x)))
                    return(car(x));
        }
        else
        {
            for (x = vector_element(sc->symbol_table, location); is_pair(x); x = cdr(x))
                if ((hash == pair_raw_hash(x)) &&
                        (len == pair_raw_len(x)) &&
                        (strings_are_equal_with_length(name, pair_raw_name(x), len))) /* length here because name might not be null-terminated */
                    return(car(x));
        }
        return(new_symbol(sc, name, len, hash, location));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8dae
movq %rax, %r12
movl $0x7fed, %ecx           # imm = 0x7FED
xorl %edx, %edx
divq %rcx
movq %rdx, %r13
movq 0x148(%r15), %rax
leal (,%rdx,8), %ebp
addq 0x10(%rax), %rbp
cmpq $0x9, %rbx
jge 0x8ca0
movq (%rbp), %rbp
cmpb $0x1, (%rbp)
jne 0x8cd1
cmpq 0x18(%rbp), %r12
jne 0x8c9a
movl 0x2c(%rbp), %eax
cmpq %rbx, %rax
je 0x8cf3
addq $0x10, %rbp
jmp 0x8c82
movq (%rbp), %rbp
cmpb $0x1, (%rbp)
jne 0x8cd1
cmpq 0x18(%rbp), %r12
jne 0x8ccb
movl 0x2c(%rbp), %eax
cmpq %rbx, %rax
jne 0x8ccb
movq 0x20(%rbp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x70ab0
testb %al, %al
jne 0x8cf3
addq $0x10, %rbp
jmp 0x8ca0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movl %r13d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9234
movq 0x8(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_symbol_table_find_name
s7_pointer s7_symbol_table_find_name(s7_scheme *sc, const char *name)
    {
        uint64_t hash;
        uint32_t location;
        s7_pointer result;

        hash = raw_string_hash((const uint8_t *)name, safe_strlen(name));
        location = hash % SYMBOL_TABLE_SIZE;
        result = symbol_table_find_by_name(sc, name, hash, location);
        if (is_null(result))
            return(NULL);

        return(result);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0x8d06
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8dae
movq %rax, %r14
movl $0x7fed, %ecx           # imm = 0x7FED
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
movq 0x110(%r12), %r13
movq 0x148(%r12), %rax
shll $0x3, %r15d
addq 0x10(%rax), %r15
movq (%r15), %r15
cmpq %r13, %r15
je 0x8d92
cmpq %r14, 0x18(%r15)
jne 0x8d8c
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x70b07
testb %al, %al
jne 0x8d97
addq $0x10, %r15
jmp 0x8d6e
movq %r13, %rcx
jmp 0x8d9b
movq 0x8(%r15), %rcx
xorl %eax, %eax
cmpq %r13, %rcx
cmovneq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: raw_string_hash
static inline uint64_t raw_string_hash(const uint8_t *key, s7_int len)
    {
        uint64_t x;
        uint8_t *cx = (uint8_t *)&x;
        x = 0;
        if (len <= 8)
            memcpy((void *)cx, (void *)key, len);
        else
        {
            uint64_t y;
            uint8_t *cy = (uint8_t *)&y;
            memcpy((void *)cx, (void *)key, 8);
            y = 0;
            len -= 8;
            memcpy((void *)cy, (void *)(key + 8), (len > 8) ? 8 : len);
            x += y;  /* better than |= but still not great if (for example) > 1B gensyms -- maybe add z? */
        }
        return(x);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rsi
andq $0x0, 0x8(%rsp)
cmpq $0x8, %rax
jg 0x8ddc
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rdx
callq 0x83e0
movq (%rbx), %rbx
jmp 0x8e06
movq (%rsi), %rbx
leaq 0x10(%rsp), %r14
andq $0x0, (%r14)
addq $0x8, %rsi
cmpq $0x10, %rax
pushq $0x10
popq %rdx
cmovbq %rax, %rdx
addq $-0x8, %rdx
movq %r14, %rdi
callq 0x83e0
addq (%r14), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_for_each_symbol_name
bool s7_for_each_symbol_name(s7_scheme *sc, bool (*symbol_func)(const char *symbol_name, void *data), void *data)
    {
        /* this includes the special constants #<unspecified> and so on for simplicity -- are there any others? */
        int32_t i;
        s7_pointer x;

        for (i = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                if (symbol_func(symbol_name(car(x)), data))
                    return(true);

        return((symbol_func("#t", data))             ||
                (symbol_func("#f", data))             ||
                (symbol_func("#<unspecified>", data)) ||
                (symbol_func("#<undefined>", data))   ||
                (symbol_func("#<eof>", data))         ||
                (symbol_func("#true", data))          ||
                (symbol_func("#false", data)));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x7fed, %r15           # imm = 0x7FED
je 0x8e71
movq 0x148(%r14), %rax
leaq (,%r15,8), %r12
addq 0x10(%rax), %r12
movq (%r12), %r12
cmpq 0x110(%r14), %r12
je 0x8e6c
movq 0x8(%r12), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq *%r13
addq $0x10, %r12
testb %al, %al
je 0x8e42
jmp 0x8ed7
incq %r15
jmp 0x8e26
leaq 0xce664(%rip), %rdi     # 0xd74dc
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x8ed7
leaq 0xcedd2(%rip), %rdi     # 0xd7c5b
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x8ed7
leaq 0xcef39(%rip), %rdi     # 0xd7dd3
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x8ed7
leaq 0xcd0d9(%rip), %rdi     # 0xd5f84
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x8ed7
leaq 0xcd0d5(%rip), %rdi     # 0xd5f91
movq %rbx, %rsi
callq *%r13
testb %al, %al
jne 0x8ed7
leaq 0xcd0cb(%rip), %rdi     # 0xd5f98
movq %rbx, %rsi
callq *%r13
testb %al, %al
je 0x8ee3
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xcd0b4(%rip), %rdi     # 0xd5f9e
movq %rbx, %rsi
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_for_each_symbol
bool s7_for_each_symbol(s7_scheme *sc, bool (*symbol_func)(const char *symbol_name, void *data), void *data)
    {
        int32_t i;
        s7_pointer x;

        for (i = 0; i < SYMBOL_TABLE_SIZE; i++)
            for (x = vector_element(sc->symbol_table, i); is_not_null(x); x = cdr(x))
                if (symbol_func(symbol_name(car(x)), data))
                    return(true);

        return(false);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq $0x7fed, %r12           # imm = 0x7FED
je 0x8f5a
movq 0x148(%r15), %rax
leaq (,%r12,8), %r13
addq 0x10(%rax), %r13
movq (%r13), %r13
cmpq 0x110(%r15), %r13
je 0x8f55
movq 0x8(%r13), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq *%r14
addq $0x10, %r13
testb %al, %al
je 0x8f2c
jmp 0x8f5a
incq %r12
jmp 0x8f10
cmpq $0x7fed, %r12           # imm = 0x7FED
setb %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_gensym
s7_pointer s7_gensym(s7_scheme *sc, const char *prefix)
    {
        block_t *b;
        char *name;
        uint32_t location;
        s7_int len;
        uint64_t hash;
        s7_pointer x;

        len = safe_strlen(prefix) + 32;
        b = mallocate(sc, len);
        name = (char *)block_data(b);
        /* there's no point in heroic efforts here to avoid name collisions -- the user can screw up no matter what we do */
        name[0] = '\0';
        len = catstrs(name, len, "{", (prefix) ? prefix : "", "}-", pos_int_to_str_direct(sc, sc->gensym_counter++), NULL);
        hash = raw_string_hash((const uint8_t *)name, len);
        location = hash % SYMBOL_TABLE_SIZE;
        x = new_symbol(sc, name, len, hash, location);  /* not T_GENSYM -- might be called from outside */
        liberate(sc, b);
        return(x);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8d06
leaq 0x20(%rax), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9037
movq %rax, %r14
movq (%rax), %r15
testq %r13, %r13
leaq 0xdf4c8(%rip), %rbp     # 0xe846e
cmovneq %r13, %rbp
movb $0x0, (%r15)
movl 0x220(%rbx), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x220(%rbx)
movq %rbx, %rdi
callq 0x91f9
andq $0x0, (%rsp)
leaq 0xccfd4(%rip), %rdx     # 0xd5fa5
leaq 0xccfcf(%rip), %r8      # 0xd5fa7
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rcx
movq %rax, %r9
xorl %eax, %eax
callq 0x90f7
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x8dae
movq %rax, %rcx
movl $0x7fed, %esi           # imm = 0x7FED
xorl %edx, %edx
divq %rsi
movq %rdx, %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9234
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9439
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: mallocate
static inline block_t *mallocate(s7_scheme *sc, size_t bytes)
    {
        block_t *p;
        if (bytes > 0)
        {
            int32_t index;
            if (bytes <= 8)
                index = 3;
            else
            {
                if (bytes <= 256)
                    index = bits[bytes - 1];
                else
                {
                    if (bytes <= 65536)
                        index = 8 + bits[(bytes - 1) >> 8];
                    else index = TOP_BLOCK_LIST; /* expansion to (1 << 17) made no difference */
                }
            }
            p = sc->block_lists[index];
            if (p)
            {
                sc->block_lists[index] = (block_t *)block_next(p);
                /* block_next(p) = NULL; */
            }
            else
            {
                p = mallocate_block(sc);
                block_data(p) = (void *)alloc_permanent_string(sc, (index < TOP_BLOCK_LIST) ? (size_t)(1 << index) : bytes);
                block_set_index(p, index);
            }
        }
        else p = mallocate_block(sc);
        block_set_size(p, bytes);
        return(p);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x9054
cmpq $0x9, %rbx
jae 0x9061
pushq $0x3
popq %rbp
jmp 0x9095
movq %r14, %rdi
callq 0xb93f
movq %rax, %r15
jmp 0x90de
cmpq $0x100, %rbx            # imm = 0x100
ja 0x9077
leaq 0xcbebf(%rip), %rax     # 0xd4f30
movl -0x4(%rax,%rbx,4), %ebp
jmp 0x9095
cmpq $0x10000, %rbx          # imm = 0x10000
ja 0x90f0
leaq -0x1(%rbx), %rax
shrq $0x8, %rax
leaq 0xcbea1(%rip), %rcx     # 0xd4f30
movl (%rcx,%rax,4), %ebp
addl $0x8, %ebp
movslq %ebp, %rax
movq 0x838(%r14,%rax,8), %r15
testq %r15, %r15
je 0x90b3
movq 0x18(%r15), %rcx
movq %rcx, 0x838(%r14,%rax,8)
jmp 0x90de
movq %r14, %rdi
callq 0xb93f
movq %rax, %r15
pushq $0x1
popq %rax
movl %ebp, %ecx
shll %cl, %eax
cmpl $0x11, %ebp
movslq %eax, %rsi
cmovgeq %rbx, %rsi
movq %r14, %rdi
callq 0xd3b1
movq %rax, (%r15)
movl %ebp, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x11
jmp 0x9051
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: catstrs
static size_t catstrs(char *dst, size_t len, ...) /* NULL-terminated arg list */
    {
        const char *s, *dend;
        char *d;
        va_list ap;
        d = dst;
        dend = (const char *)(dst + len);
        while ((*d) && (d < dend)) d++;
        va_start(ap, len);
        for (s = va_arg(ap, const char *); s != NULL; s = va_arg(ap, const char *))
            while ((*s) && (d < dend)) {*d++ = *s++;}
        *d = '\0';
        va_end (ap);
        return(d - dst);
    }

// Assembly:
subq $0x58, %rsp
movq %rdx, -0x50(%rsp)
movq %rcx, -0x48(%rsp)
movq %r8, -0x40(%rsp)
movq %r9, -0x38(%rsp)
testb %al, %al
je 0x913a
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
addq %rdi, %rsi
movq %rdi, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, (%rcx)
je 0x9151
cmpq %rsi, %rcx
movq %rax, %rcx
jb 0x9140
leaq -0x60(%rsp), %rcx
movq %rcx, -0x70(%rsp)
leaq 0x60(%rsp), %rcx
movq %rcx, -0x78(%rsp)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, -0x80(%rsp)
movabsq $0x10, %rdx
cmpq $0x28, %rdx
ja 0x9195
movq %rdx, %rcx
addq -0x70(%rsp), %rcx
addl $0x8, %edx
movl %edx, -0x80(%rsp)
jmp 0x91a3
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x78(%rsp)
decq %rax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x91ee
movb (%rcx), %dl
testb %dl, %dl
je 0x91c3
cmpq %rsi, %rax
jae 0x91c3
incq %rcx
movb %dl, (%rax)
incq %rax
jmp 0x91ae
movl -0x80(%rsp), %edx
cmpq $0x28, %rdx
ja 0x91de
movq %rdx, %rcx
addq -0x70(%rsp), %rcx
addl $0x8, %edx
movl %edx, -0x80(%rsp)
jmp 0x91a6
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x78(%rsp)
jmp 0x91a6
movb $0x0, (%rax)
subq %rdi, %rax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: pos_int_to_str_direct
static char *pos_int_to_str_direct(s7_scheme *sc, s7_int num)
    {
        char *p;
        p = (char *)(sc->int_to_str4 + INT_TO_STR_SIZE - 1);
        *p-- = '\0';
        do {*p-- = "0123456789"[num % 10]; num /= 10;} while (num);
        return((char *)(p + 1));
    }

// Assembly:
movb $0x0, 0xb6f(%rdi)
addq $0xb6f, %rdi            # imm = 0xB6F
leaq 0xd92d2(%rip), %rcx     # 0xe24e0
pushq $0xa
popq %r8
movq %rsi, %rax
cqto
idivq %r8
movb (%rdx,%rcx), %dl
movb %dl, -0x1(%rdi)
decq %rdi
addq $0x9, %rsi
cmpq $0x12, %rsi
movq %rax, %rsi
ja 0x9212
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: liberate
static inline void liberate(s7_scheme *sc, block_t *p)
    {
        if (block_index(p) != TOP_BLOCK_LIST)
        {
            block_next(p) = (struct block_t *)sc->block_lists[block_index(p)];
            sc->block_lists[block_index(p)] = p;
        }
        else
        {
            if (block_data(p))
            {
#if S7_DEBUGGING
                permanent_string_len -= block_size(p);
#endif
                free(block_data(p));
                block_data(p) = NULL;
            }
            block_set_index(p, BLOCK_LIST);
            block_next(p) = (struct block_t *)sc->block_lists[block_index(p)];
            sc->block_lists[block_index(p)] = p;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %rax
cmpq $0x11, %rax
jne 0x946b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x945e
callq 0x8050
andq $0x0, (%rbx)
andl $0x0, 0x8(%rbx)
addq $0x838, %r14            # imm = 0x838
jmp 0x9476
leaq (%r14,%rax,8), %r14
addq $0x838, %r14            # imm = 0x838
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: remove_function_from_heap
static void remove_function_from_heap(s7_scheme *sc, s7_pointer value)
    {
        s7_pointer lt;

        s7_remove_from_heap(sc, closure_args(value));
        s7_remove_from_heap(sc, closure_body(value));

        /* remove closure if it's local to current func (meaning (define f (let ...) (lambda ...)) removes the enclosing let) */
        lt = closure_let(value); /* closure_let and all its outlets can't be rootlet */
        if ((is_let(lt)) && (!let_removed(lt)) && (lt != sc->shadow_rootlet))
        {
            lt = outlet(lt);
            if ((is_let(lt)) && (!let_removed(lt)) && (lt != sc->shadow_rootlet))
            {
                remove_let_from_heap(sc, lt);
                lt = outlet(lt);
                if ((is_let(lt)) && (!let_removed(lt)) && (lt != sc->shadow_rootlet))
                    remove_let_from_heap(sc, lt);
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x9897
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x9897
movq 0x18(%r14), %rax
cmpb $0x1c, (%rax)
jne 0x97bf
testb $0x2, 0x3(%rax)
jne 0x97bf
movq 0x158(%rbx), %rcx
cmpq %rcx, %rax
je 0x97bf
movq 0x10(%rax), %r14
cmpb $0x1c, (%r14)
jne 0x97bf
cmpq %rcx, %r14
je 0x97bf
movq (%r14), %rax
andl $0x2000000, %eax        # imm = 0x2000000
jne 0x97bf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x70b20
movq 0x10(%r14), %rsi
cmpb $0x1c, (%rsi)
jne 0x97bf
testb $0x2, 0x3(%rsi)
jne 0x97bf
cmpq 0x158(%rbx), %rsi
je 0x97bf
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x70b20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: slot_set_value_with_hook_1
static void slot_set_value_with_hook_1(s7_scheme *sc, s7_pointer slot, s7_pointer value)
    {
        /* (set! (hook-functions *rootlet-redefinition-hook*) (list (lambda (hook) (format *stderr* "~A ~A~%" (hook 'symbol) (hook 'value))))) */
        s7_pointer symbol;
        symbol = slot_symbol(slot);
        if ((global_slot(symbol) == slot) &&
                (value != slot_value(slot)))
            s7_call(sc, sc->rootlet_redefinition_hook, set_elist_2(sc, symbol, value));
        slot_set_value(slot, value);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
cmpq %rsi, 0x10(%rax)
jne 0x9821
cmpq %rbx, 0x10(%r14)
je 0x9821
movq 0x200(%rdi), %rsi
movq 0x6e0(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x6e0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, 0x8(%rax)
movq 0x6e0(%rdi), %rdx
callq 0x35e2b
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: make_permanent_slot
static s7_pointer make_permanent_slot(s7_scheme *sc, s7_pointer symbol, s7_pointer value)
    {
        s7_pointer x;
        x = alloc_pointer(sc);
#if S7_DEBUGGING
        permanent_slots++;
#endif
        set_type(x, T_SLOT | T_UNHEAP);
        slot_set_symbol(x, symbol);
        slot_set_value(x, value);
        return(x);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0xd35f
movabsq $0x4000000000000020, %rcx # imm = 0x4000000000000020
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: reallocate
static block_t *reallocate(s7_scheme *sc, block_t *op, size_t bytes)
    {
        block_t *np;
        np = mallocate(sc, bytes);
        if (block_data(op))  /* presumably block_data(np) is not null */
            memcpy((uint8_t *)(block_data(np)), (uint8_t *)(block_data(op)), block_size(op));
        liberate(sc, op);
        return(np);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x9037
movq %rax, %r15
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x9883
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
callq 0x83e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9439
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_varlet
s7_pointer s7_varlet(s7_scheme *sc, s7_pointer env, s7_pointer symbol, s7_pointer value)
    {
        if (!is_let(env))
            return(wrong_type_argument_with_type(sc, sc->varlet_symbol, 1, env, a_let_string));

        if (!is_symbol(symbol))
            return(wrong_type_argument_with_type(sc, sc->varlet_symbol, 2, symbol, a_symbol_string));

        if ((is_slot(global_slot(symbol))) &&
                (is_syntax(slot_value(global_slot(symbol)))))
            return(wrong_type_argument_with_type(sc, sc->varlet_symbol, 2, symbol, wrap_string(sc, "a non-syntactic name", 20)));

        if (env == sc->rootlet)
        {
            if (is_slot(global_slot(symbol)))
                slot_set_value(global_slot(symbol), value);
            else s7_make_slot(sc, env, symbol, value);
        }
        else make_slot_1(sc, env, symbol, value);
        return(value);
    }

// Assembly:
pushq %rbx
movq %rsi, %rax
cmpb $0x1c, (%rsi)
jne 0x9b38
movq %rcx, %rbx
movq %rdx, %rcx
cmpb $0xa, (%rdx)
jne 0x9b5d
movq 0x10(%rcx), %rdx
cmpb $0x20, (%rdx)
jne 0x9b80
movq 0x10(%rdx), %rsi
cmpb $0x9, (%rsi)
jne 0x9b99
movq 0x1640(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x10be63(%rip), %rdx    # 0x115960
movq 0x140(%rdi), %r8
movq 0x820(%rdi), %rax
movslq 0x7dc(%rdi), %r10
movq (%rax,%r10,8), %r9
leal 0x1(%r10), %eax
andl $0x7, %eax
movl %eax, 0x7dc(%rdi)
leaq 0xcc4a7(%rip), %rax     # 0xd5fd1
movq %rax, 0x10(%r9)
movq $0x14, 0x8(%r9)
jmp 0x9b7d
movq 0x1640(%rdi), %rcx
movq 0x8(%rcx), %rsi
movq 0x10be0e(%rip), %rdx    # 0x115958
movq 0x140(%rdi), %r8
movq 0x10fe00(%rip), %r9     # 0x119958
movq %rax, %rcx
jmp 0x9b7d
movq 0x1640(%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x10bdf1(%rip), %rdx    # 0x115960
movq 0x140(%rdi), %r8
movq 0x10fde3(%rip), %r9     # 0x119960
popq %rbx
jmp 0x9bbb
cmpq %rax, 0x150(%rdi)
jne 0x9ba2
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0x94fb
jmp 0x9bb0
cmpq %rax, 0x150(%rdi)
je 0x9bb5
movq %rax, %rsi
movq %rcx, %rdx
movq %rbx, %rcx
callq 0x9a09
movq %rbx, %rax
popq %rbx
retq
movq %rbx, 0x10(%rdx)
jmp 0x9bb0
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: wrong_type_arg_error_prepackaged
static s7_pointer wrong_type_arg_error_prepackaged(s7_scheme *sc, s7_pointer caller, s7_pointer arg_n, s7_pointer arg, s7_pointer typnam, s7_pointer descr)
                {
                    /* info list is '(format_string caller arg_n arg type_name descr) */
                    s7_pointer p;
                    p = cdr(sc->wrong_type_arg_info);  /* info list is '(format_string caller arg_n arg type_name descr) */
                    set_car(p, caller);  p = cdr(p);
                    set_car(p, arg_n);   p = cdr(p);
                    set_car(p, arg);     p = cdr(p);
                    set_car(p, (typnam == sc->unused) ? prepackaged_type_name(sc, arg) : typnam);
                    p = cdr(p);
                    set_car(p, descr);
                    return(s7_error(sc, sc->wrong_type_arg_symbol, sc->wrong_type_arg_info));
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %rdi, %r14
movq 0x1ee0(%rdi), %rax
movq 0x10(%rax), %rax
movq %rsi, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rdx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %r15
cmpq %r8, 0x140(%rdi)
jne 0x9c00
movq %r14, %rdi
movq %rcx, %rsi
callq 0x7cf40
movq %rax, %r8
movq %r8, 0x8(%r15)
movq 0x10(%r15), %rax
movq %rbx, 0x8(%rax)
movq 0x1940(%r14), %rsi
movq 0x1ee0(%r14), %rdx
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2cdc0
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: s7_apply_function
s7_pointer s7_apply_function(s7_scheme *sc, s7_pointer fnc, s7_pointer args)
                {
                    TRACK(sc);
#if S7_DEBUGGING
                    {
                        s7_pointer p;
                        int32_t argnum;
                        T_Pos(fnc);       /* not T_App here: (length (openlet (inlet 'length 8))) should raise an error */
                        for (argnum = 0, p = T_Pos(args); is_pair(p); argnum++, p = T_Pos(cdr(p)))
                            T_Pos(car(p));
                    }
#endif

                    set_current_code(sc, history_cons(sc, fnc, args));
                    if (is_c_function(fnc))
                        return(c_function_call(fnc)(sc, args));

                    push_stack(sc, OP_EVAL_DONE, sc->args, sc->code);
                    sc->code = fnc;
                    sc->args = (needs_copied_args(sc->code)) ? copy_list(sc, args) : args;
                    eval(sc, OP_APPLY);
                    /* we're limited in choices here -- the caller might be (say) car(sc->t1_1) = c_call(...) where the c_call
                     *   happens to fallback on a method -- we can't just push OP_APPLY and drop back into the evaluator normally.
                     */
                    return(sc->value);
                }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x28(%rdi)
cmpb $0x30, (%rsi)
jb 0xa366
movq 0x10(%rsi), %rax
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
jmpq *%rax
movq (%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x50(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rbx), %rax
movq $0x1df, 0x18(%rax)      # imm = 0x1DF
addq $0x20, 0x50(%rbx)
movq %rsi, (%rbx)
testb $0x10, 0x3(%rsi)
je 0xa3b0
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x35492
movq %rax, %rdx
movq %rdx, 0x10(%rbx)
movl $0x198, %esi            # imm = 0x198
movq %rbx, %rdi
callq 0xe1a8
movq 0x20(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: call_let_ref_fallback
static s7_pointer call_let_ref_fallback(s7_scheme *sc, s7_pointer env, s7_pointer symbol)
    {
        s7_pointer p;
        /* args could be protected via let = stack_end[1] */
        push_stack_no_let(sc, OP_GC_PROTECT, sc->value, sc->code);
        p = s7_apply_function(sc, find_method(sc, env, sc->let_ref_fallback_symbol), set_qlist_2(sc, env, symbol));
        sc->stack_end -= 4;
        sc->code =  T_Pos(sc->stack_end[0]);
        sc->value =  T_Pos(sc->stack_end[2]);
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x20(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rdi)
movq 0x1228(%rdi), %rdx
callq 0x888f
movq 0x720(%rbx), %rcx
movq %r15, 0x8(%rcx)
movq 0x720(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, 0x8(%rcx)
movq 0x720(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa34c
movq 0x50(%rbx), %rcx
leaq -0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq -0x20(%rcx), %rdx
movq %rdx, (%rbx)
movq -0x10(%rcx), %rcx
movq %rcx, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/BernardTatin[P]s7sh/s7.c
// Function: call_let_set_fallback
static s7_pointer call_let_set_fallback(s7_scheme *sc, s7_pointer env, s7_pointer symbol, s7_pointer value)
    {
        s7_pointer p;
        push_stack_no_let(sc, OP_GC_PROTECT, sc->value, sc->code);
        p = s7_apply_function(sc, find_method(sc, env, sc->let_set_fallback_symbol), set_qlist_3(sc, env, symbol, value));
        sc->stack_end -= 4;
        sc->code =  T_Pos(sc->stack_end[0]);
        sc->value =  T_Pos(sc->stack_end[2]);
        return(p);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, (%rcx)
movq 0x20(%rdi), %rax
movq 0x50(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x50(%rdi), %rax
movq $0x1, 0x18(%rax)
addq $0x20, 0x50(%rdi)
movq 0x1238(%rdi), %rdx
callq 0x888f
movq 0x728(%rbx), %rcx
movq %r12, 0x8(%rcx)
movq 0x728(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %r15, 0x8(%rcx)
movq 0x728(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq %r14, 0x8(%rcx)
movq 0x728(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa34c
movq 0x50(%rbx), %rcx
leaq -0x20(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq -0x20(%rcx), %rdx
movq %rdx, (%rbx)
movq -0x10(%rcx), %rcx
movq %rcx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq