LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_deposit
int monitor_deposit(monitor_t *_this, unsigned address, unsigned value) {
	switch (_this->monitor_type) {
	case monitor_odt:
		return monitor_odt_deposit(_this, address, value);
	case monitor_m9312:
	case monitor_m9301: // only difference is the prompt
		return monitor_m9312_deposit(_this, address, value);
        case monitor_1144:
            return monitor_1144_deposit(_this, address, value);
	default:
		return error_set(ERROR_MONITOR, "monitor_deposit(): Illegal boot monitor %u selected",
				_this->monitor_type);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
je 0x17919
jmp 0x17902
movl -0x1c(%rbp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0x1792d
jmp 0x1790f
movl -0x1c(%rbp), %eax
subl $0x5, %eax
je 0x17941
jmp 0x17955
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x17980
movl %eax, -0x4(%rbp)
jmp 0x17971
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x17ae0
movl %eax, -0x4(%rbp)
jmp 0x17971
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x17bf0
movl %eax, -0x4(%rbp)
jmp 0x17971
movq -0x10(%rbp), %rax
movl (%rax), %edx
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x67b9(%rip), %rsi      # 0x1e120
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_odt_deposit
static int monitor_odt_deposit(monitor_t *_this, unsigned address, unsigned value) {
	char buffer[256];
	char *answer;

	// write <address>/
	sprintf(buffer, "%o/", address);
	if (monitor_puts_echocheck(_this, buffer, _this->responsetime_us)) // verify address
		return error_code;
	// LSI ODT responds with current value, or ?
	answer = monitor_gets(_this, _this->responsetime_us); // read whole answer
	// check for ?. if memory inaccessible
	if (strchr(answer, '?') != NULL) {
		monitor_trace_dump(ferr);
		return error_set(ERROR_MONITOR, "Error reading addr %o\n", address);
	} else {
		// deposit
		sprintf(buffer, "%o", value);
		if (monitor_puts_echocheck(_this, buffer, _this->responsetime_us)) // verify digits
			return error_code;
		monitor_puts(_this, CR);
		answer = monitor_gets(_this, _this->responsetime_us); // read prompt
	}
	// answer is now the "?\n@" or the "\n@". verify
	if (monitor_wait_prompt(_this, answer)) {
		return error_set(ERROR_MONITOR, "ODT deposit: @-prompt not found");
	}
	return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x6806(%rip), %rsi      # 0x1e1ac
movb $0x0, %al
callq 0x3520
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x176b0
cmpl $0x0, %eax
je 0x179da
leaq 0xdb68(%rip), %rax      # 0x25538
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x17ad2
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x175b0
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rdi
movl $0x3f, %esi
callq 0x31c0
cmpq $0x0, %rax
je 0x17a35
leaq 0xdb21(%rip), %rax      # 0x25530
movq (%rax), %rdi
callq 0x17230
movl -0x14(%rbp), %edx
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x678a(%rip), %rsi      # 0x1e1b0
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x17ad2
leaq -0x120(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x67a3(%rip), %rsi      # 0x1e1e9
movb $0x0, %al
callq 0x3520
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x176b0
cmpl $0x0, %eax
je 0x17a77
leaq 0xdac8(%rip), %rax      # 0x25538
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x17ad2
movq -0x10(%rbp), %rdi
leaq 0x6567(%rip), %rsi      # 0x1dfe9
callq 0x173b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x175b0
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x17440
cmpl $0x0, %eax
je 0x17acb
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x6708(%rip), %rsi      # 0x1e1c7
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x17ad2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_m9312_deposit
static int monitor_m9312_deposit(monitor_t *_this, unsigned address, unsigned value) {
	char buffer[256];
	char *answer;

	// write L <address>, if different from previous
	if (address != _this->last_address + 2) {
		if (monitor_m9312_load_addr(_this, address))
			return error_code;
	} else
		_this->last_address = address; // deposit increments the "current address"

	// deposit
	sprintf(buffer, "D %o", value);
	if (monitor_puts_echocheck(_this, buffer, _this->responsetime_us)) // verify digits
		return error_code;
	monitor_puts(_this, CR);
	answer = monitor_gets(_this, _this->responsetime_us); // read prompt
	if (monitor_wait_prompt(_this, answer))
		return error_set(ERROR_MONITOR, "M9312/M9301 deposit: %s-prompt not found",
				_this->prompt);



	return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
je 0x17b2a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17fc0
cmpl $0x0, %eax
je 0x17b28
leaq 0xda1a(%rip), %rax      # 0x25538
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x17bd9
jmp 0x17b34
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
leaq -0x120(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x66a2(%rip), %rsi      # 0x1e1e7
movb $0x0, %al
callq 0x3520
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x176b0
cmpl $0x0, %eax
je 0x17b76
leaq 0xd9c9(%rip), %rax      # 0x25538
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x17bd9
movq -0x10(%rbp), %rdi
leaq 0x6468(%rip), %rsi      # 0x1dfe9
callq 0x173b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x175b0
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x17440
cmpl $0x0, %eax
je 0x17bd2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x6626(%rip), %rsi      # 0x1e1ec
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x17bd9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_1144_deposit
static int monitor_1144_deposit(monitor_t *_this, unsigned address, unsigned value) {
    char buffer[256];
    char *answer;

    // deposit
    sprintf(buffer, "D %o %o", address, value);
    if (monitor_puts_echocheck(_this, buffer, _this->responsetime_us)) // verify digits
        return error_code;
    monitor_puts(_this, CR);
    answer = monitor_gets(_this, _this->responsetime_us); // read prompt
    if (monitor_wait_prompt(_this, answer))
        return error_set(ERROR_MONITOR, "PDP-11/44 deposit: %s-prompt not found",
                         _this->prompt);
    return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x662f(%rip), %rsi      # 0x1e248
movb $0x0, %al
callq 0x3520
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x176b0
cmpl $0x0, %eax
je 0x17c4a
leaq 0xd8f5(%rip), %rax      # 0x25538
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x17cad
movq -0x10(%rbp), %rdi
leaq 0x6394(%rip), %rsi      # 0x1dfe9
callq 0x173b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x175b0
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x17440
cmpl $0x0, %eax
je 0x17ca6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x65b6(%rip), %rsi      # 0x1e250
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x17cad
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_go
int monitor_go(monitor_t *_this, unsigned address, int no_go) {
	switch (_this->monitor_type) {
	case monitor_odt:
		return monitor_odt_go(_this, address, no_go);
	case monitor_m9312:
	case monitor_m9301: // only difference is the prompt
		return monitor_m9312_go(_this, address, no_go);
        case monitor_1144:
            return monitor_1144_go(_this, address, no_go);
	default:
		return error_set(ERROR_MONITOR, "monitor_go(): Illegal boot monitor %u selected",
				_this->monitor_type);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
je 0x17cf9
jmp 0x17ce2
movl -0x1c(%rbp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0x17d0d
jmp 0x17cef
movl -0x1c(%rbp), %eax
subl $0x5, %eax
je 0x17d21
jmp 0x17d35
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x17d60
movl %eax, -0x4(%rbp)
jmp 0x17d51
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x17e40
movl %eax, -0x4(%rbp)
jmp 0x17d51
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x17ef0
movl %eax, -0x4(%rbp)
jmp 0x17d51
movq -0x10(%rbp), %rax
movl (%rax), %edx
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x640d(%rip), %rsi      # 0x1e154
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_odt_go
static int monitor_odt_go(monitor_t *_this, unsigned address, int no_go) {
	char buffer[256];
	char *s;

	if (no_go) {
		sprintf(buffer, "%o", address);
		monitor_puts_echocheck(_this, buffer, _this->responsetime_us);
	} else {
		sprintf(buffer, "%oG", address);
		// No CR, "G" starts program execution immediately
		monitor_puts_echocheck(_this, buffer, _this->responsetime_us);
		// echo all command output, wait 1 second
		do {
			s = monitor_gets(_this, _this->responsetime_us);
		} while (s && strlen(s));
	}
	return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x17dac
leaq -0x110(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x645d(%rip), %rsi      # 0x1e1e9
movb $0x0, %al
callq 0x3520
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x176b0
jmp 0x17e29
leaq -0x110(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x64ba(%rip), %rsi      # 0x1e277
movb $0x0, %al
callq 0x3520
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x176b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x175b0
movq %rax, -0x118(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x118(%rbp)
movb %al, -0x119(%rbp)
je 0x17e1d
movq -0x118(%rbp), %rdi
callq 0x3190
cmpq $0x0, %rax
setne %al
movb %al, -0x119(%rbp)
movb -0x119(%rbp), %al
testb $0x1, %al
jne 0x17ddb
jmp 0x17e29
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_m9312_go
static int monitor_m9312_go(monitor_t *_this, unsigned address, int no_go) {
	char *s;

	// set start address
	if (monitor_m9312_load_addr(_this, address))
		return error_code;

	// write the "S"
	monitor_puts_echocheck(_this, "S", _this->responsetime_us);

	if (!no_go) {
		monitor_puts(_this, CR);
		// L<CR> starts program execution
		// echo all command output, wait 1 second
		do {
			s = monitor_gets(_this, _this->responsetime_us);
		} while (s && strlen(s));
	}
	return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17fc0
cmpl $0x0, %eax
je 0x17e71
leaq 0xd6ce(%rip), %rax      # 0x25538
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x17ee1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0x481e(%rip), %rsi      # 0x1c6a1
callq 0x176b0
cmpl $0x0, -0x18(%rbp)
jne 0x17eda
movq -0x10(%rbp), %rdi
leaq 0x6150(%rip), %rsi      # 0x1dfe9
callq 0x173b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x175b0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x17ed1
movq -0x20(%rbp), %rdi
callq 0x3190
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x17e9e
jmp 0x17eda
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_1144_go
static int monitor_1144_go(monitor_t *_this, unsigned address, int no_go) {
    char buffer[256];
    char *s;

    sprintf(buffer, "S %o", address);
    if (monitor_puts_echocheck(_this, buffer, _this->responsetime_us)) // verify digits
        return error_code;

    if(! no_go) {
        monitor_puts(_this, CR);
        // L<CR> starts program execution
        // echo all command output, wait 1 second
        do {
            s = monitor_gets(_this, _this->responsetime_us);
        } while (s && strlen(s));
    }
    return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x6365(%rip), %rsi      # 0x1e27b
movb $0x0, %al
callq 0x3520
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x176b0
cmpl $0x0, %eax
je 0x17f47
leaq 0xd5f8(%rip), %rax      # 0x25538
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x17fb2
cmpl $0x0, -0x18(%rbp)
jne 0x17fab
movq -0x10(%rbp), %rdi
leaq 0x6091(%rip), %rsi      # 0x1dfe9
callq 0x173b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x175b0
movq %rax, -0x128(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x128(%rbp)
movb %al, -0x129(%rbp)
je 0x17f9f
movq -0x128(%rbp), %rdi
callq 0x3190
cmpq $0x0, %rax
setne %al
movb %al, -0x129(%rbp)
movb -0x129(%rbp), %al
testb $0x1, %al
jne 0x17f5d
jmp 0x17fab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/monitor.c
// Function: monitor_m9312_load_addr
static int monitor_m9312_load_addr(monitor_t *_this, unsigned address) {
	char buffer[256];
	char *answer;
	_this->last_address = 0xffffffff; // invalidate
	sprintf(buffer, "L %o", address);
	if (monitor_puts_echocheck(_this, buffer, _this->responsetime_us)) // verify address
		return error_code;
	monitor_puts(_this, CR);
	answer = monitor_gets(_this, _this->responsetime_us); // read prompt
	if (monitor_wait_prompt(_this, answer))
		return error_set(ERROR_MONITOR, "M9312/M9301 address load: %s-prompt not found",
				_this->prompt);
	_this->last_address = address;
	return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
leaq -0x120(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x6227(%rip), %rsi      # 0x1e215
movb $0x0, %al
callq 0x3520
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x176b0
cmpl $0x0, %eax
je 0x1801f
leaq 0xd520(%rip), %rax      # 0x25538
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1808c
movq -0x10(%rbp), %rdi
leaq 0x5fbf(%rip), %rsi      # 0x1dfe9
callq 0x173b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x175b0
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x17440
cmpl $0x0, %eax
je 0x1807b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x61ab(%rip), %rsi      # 0x1e21a
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x1808c
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/bootloader.c
// Function: bootloader_show_code
void bootloader_show_code(FILE *fout, int opt_boot_address) {
	unsigned i;
	fprintf(fout, "# TU58 boot loader octal address/value dump\n");
	// dump out address/value pairs
	for (i = 0; i < obj_code_word_count; i++) {
		unsigned addr = opt_boot_address + 2 * i;
		unsigned value = obj_code[i];
		fprintf(fout, "%06o %06o\n", addr, value);
	}
	fprintf(fout, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x61c6(%rip), %rsi      # 0x1e280
movb $0x0, %al
callq 0x3300
movl $0x0, -0x10(%rbp)
cmpl $0x2b, -0x10(%rbp)
jae 0x18111
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
shll %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0xbb09(%rip), %rax      # 0x23bf0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x61ae(%rip), %rsi      # 0x1e2ad
movb $0x0, %al
callq 0x3300
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x180c8
movq -0x8(%rbp), %rdi
leaq 0x45a7(%rip), %rsi      # 0x1c6c3
movb $0x0, %al
callq 0x3300
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/bootloader.c
// Function: bootloader_download
int bootloader_download(serial_device_t *serialdevice, monitor_type_t monitor_type,
		int opt_boot_address) {
	monitor_t monitor;
	unsigned i;

	if (monitor_init(&monitor, serialdevice, monitor_type, stdout, opt_usbdelay))
		return error_set(ERROR_MONITOR, "monitor_init in bootloader_download");
	if (monitor_assert_prompt(&monitor))
		return error_set(ERROR_MONITOR,
				"Boot loader download: PDP-11 console prompt not found.");

	// dump out address/value pairs
	for (i = 0; i < obj_code_word_count; i++) {
		unsigned addr = opt_boot_address + 2 * i;
		unsigned value = obj_code[i];
		if (monitor_deposit(&monitor, addr, value))
			return error_set(ERROR_MONITOR, "bootloader_download");
	}
//monitor_trace_dump(stderr) ; //debug
	monitor_close(&monitor);
	return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq 0xae80(%rip), %rax      # 0x22fd0
movq (%rax), %rcx
leaq 0xbc2a(%rip), %rax      # 0x23d84
movl (%rax), %r8d
leaq -0x48(%rbp), %rdi
callq 0x170d0
cmpl $0x0, %eax
je 0x18186
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x6141(%rip), %rsi      # 0x1e2b8
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x18222
leaq -0x48(%rbp), %rdi
callq 0x172e0
cmpl $0x0, %eax
je 0x181ac
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x613c(%rip), %rsi      # 0x1e2dc
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x18222
movl $0x0, -0x4c(%rbp)
cmpl $0x2b, -0x4c(%rbp)
jae 0x18212
movl -0x18(%rbp), %eax
movl -0x4c(%rbp), %ecx
shll %ecx
addl %ecx, %eax
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %ecx
leaq 0xba1e(%rip), %rax      # 0x23bf0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x54(%rbp)
movl -0x50(%rbp), %esi
movl -0x54(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x178e0
cmpl $0x0, %eax
je 0x18205
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x60cf(%rip), %rsi      # 0x1e2c8
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x18222
jmp 0x18207
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x181b3
leaq -0x48(%rbp), %rdi
callq 0x17200
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/j-hoppe[P]tu58fs/bootloader.c
// Function: bootloader_go
int bootloader_go(serial_device_t *serialdevice, monitor_type_t monitor_type, int boot_address) {
	monitor_t monitor;
	if (monitor_init(&monitor, serialdevice, monitor_type, stdout, opt_usbdelay))
		return error_set(ERROR_MONITOR, "monitor_init in bootloader_go");
	if (monitor_assert_prompt(&monitor))
		return error_set(ERROR_MONITOR, "monitor_assert_prompt in bootloader_go");
	if (monitor_go(&monitor, boot_address, 0))
		return error_set(ERROR_MONITOR, "monitor_go in bootloader_go");
	return ERROR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq 0xad80(%rip), %rax      # 0x22fd0
movq (%rax), %rcx
leaq 0xbb2a(%rip), %rax      # 0x23d84
movl (%rax), %r8d
leaq -0x48(%rbp), %rdi
callq 0x170d0
cmpl $0x0, %eax
je 0x18283
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x609c(%rip), %rsi      # 0x1e313
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x182db
leaq -0x48(%rbp), %rdi
callq 0x172e0
cmpl $0x0, %eax
je 0x182a9
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x6094(%rip), %rsi      # 0x1e331
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x182db
movl -0x18(%rbp), %esi
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x17cc0
cmpl $0x0, %eax
je 0x182d4
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
leaq 0x6090(%rip), %rsi      # 0x1e358
movb $0x0, %al
callq 0xcd70
movl %eax, -0x4(%rbp)
jmp 0x182db
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/thread.c
// Function: launch
void *launch(void *arg)
{
    pthread_t   threads[NUM_THREADS];
    int         i;

    for (i = 0; i < NUM_THREADS; i++)
    {
        pthread_create(&threads[i], NULL, thread, (void *)0);
    }

    for (i = 0; i < NUM_THREADS; i++)
    {
        pthread_join(threads[i], NULL);
    }   
    printf("launch: reporting that all %d threads have terminated\n", i);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x64(%rbp)
cmpl $0xa, -0x64(%rbp)
jge 0x1546
movslq -0x64(%rbp), %rax
leaq -0x60(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x5d(%rip), %rdx        # 0x1590
movq %rcx, %rsi
callq 0x10f0
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x1513
movl $0x0, -0x64(%rbp)
cmpl $0xa, -0x64(%rbp)
jge 0x1570
movslq -0x64(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1120
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x154d
movl -0x64(%rbp), %esi
leaq 0x3a93(%rip), %rdi      # 0x500d
movb $0x0, %al
callq 0x1060
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptGetScope
Scope ExceptGetScope(
    Context *   pC)             /* pointer to thread exception context */
{
    Scope       scope;

    if (pC == NULL)
        pC = ExceptGetContext(NULL);

    ExceptPrintDebug(pC, "ExceptGetScope");

    if (pC == NULL || pC->pEx == NULL)
        scope = OUTSIDE;
    else
        scope = ((Except *)LifoPeek(pC->exStack, 1))->scope;

    return scope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x17d0
xorl %eax, %eax
movl %eax, %edi
callq 0x1810
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x17e1
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x17ea
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x1805
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x2ac0
movl 0x1b8(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptGetContext
Context * ExceptGetContext(
    Context *   pC)             /* pointer to thread exception context */
{
#if     MULTI_THREADING
    EXCEPT_THREAD_MUTEX_FUNC(1);
    if (pC == NULL && pContextHash != NULL)
        pC = HashLookup(pContextHash, EXCEPT_THREAD_ID_FUNC());
    EXCEPT_THREAD_MUTEX_FUNC(0);
    
    return pC;
#else
    return &defaultContext;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
callq 0x1870
cmpq $0x0, -0x8(%rbp)
jne 0x1856
cmpq $0x0, 0x6a03(%rip)      # 0x8238
je 0x1856
movq 0x69fa(%rip), %rax      # 0x8238
movq %rax, -0x10(%rbp)
callq 0x1100
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x30c0
movq %rax, -0x8(%rbp)
xorl %edi, %edi
callq 0x1870
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptMutex
static void ExceptMutex(
    int         mode)           /* 1: lock, 0 unlock */
{
    static volatile pthread_mutex_t mutex;
    static volatile sig_atomic_t    initialized;
    static volatile sig_atomic_t    ready;
    static volatile int             count;
    static volatile pthread_t       tid;

    if (!initialized && !initialized++)
    {
        pthread_mutex_init(&mutex, NULL);
        ready = 1;
    }
    else
    {
        while (!ready)
            ;
    }
    
    if (mode == 1)
    {
        if (tid == pthread_self())
        {
            count++;
        }
        else
        {
            pthread_mutex_lock(&mutex);
            tid = pthread_self();
            count = 1;
        }
    }
    else if (mode == 0)
    {
        if (tid == pthread_self())
        {
            if (--count == 0)
            {
                tid = 0;
                pthread_mutex_unlock(&mutex);
            }
        }
        else if (tid != 0 && tid != pthread_self())
        {
            fprintf(stderr, "Except internal error: thread attempts to unlock"
                            " without holding lock\n");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl 0x69e7(%rip), %eax      # 0x8268
cmpl $0x0, %eax
jne 0x18b8
movl 0x69dc(%rip), %eax      # 0x8268
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x69d1(%rip)      # 0x8268
cmpl $0x0, %eax
jne 0x18b8
leaq 0x699d(%rip), %rdi      # 0x8240
xorl %eax, %eax
movl %eax, %esi
callq 0x1140
movl $0x1, 0x69b6(%rip)      # 0x826c
jmp 0x18d2
jmp 0x18ba
movl 0x69ac(%rip), %eax      # 0x826c
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18ce
jmp 0x18d0
jmp 0x18ba
jmp 0x18d2
cmpl $0x1, -0x4(%rbp)
jne 0x192c
movq 0x6999(%rip), %rax      # 0x8278
movq %rax, -0x10(%rbp)
callq 0x1100
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jne 0x1905
movl 0x6976(%rip), %eax      # 0x8270
addl $0x1, %eax
movl %eax, 0x696d(%rip)      # 0x8270
jmp 0x1927
leaq 0x6934(%rip), %rdi      # 0x8240
callq 0x1150
callq 0x1100
movq %rax, 0x695b(%rip)      # 0x8278
movl $0x1, 0x6949(%rip)      # 0x8270
jmp 0x19c6
cmpl $0x0, -0x4(%rbp)
jne 0x19c4
movq 0x693b(%rip), %rax      # 0x8278
movq %rax, -0x18(%rbp)
callq 0x1100
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jne 0x197f
movl 0x6918(%rip), %eax      # 0x8270
addl $-0x1, %eax
movl %eax, 0x690f(%rip)      # 0x8270
cmpl $0x0, %eax
jne 0x197d
movq $0x0, 0x6907(%rip) # 0x8278
leaq 0x68c8(%rip), %rdi      # 0x8240
callq 0x10c0
jmp 0x19c2
movq 0x68f2(%rip), %rax      # 0x8278
cmpq $0x0, %rax
je 0x19c0
movq 0x68e5(%rip), %rax      # 0x8278
movq %rax, -0x20(%rbp)
callq 0x1100
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x19c0
movq 0x6649(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3848(%rip), %rsi      # 0x5201
movb $0x0, %al
callq 0x10a0
jmp 0x19c2
jmp 0x19c4
jmp 0x19c6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptThreadCleanup
void ExceptThreadCleanup(
    int         threadId)       /* ID of ceased thread or -1 for self */
{
#if     MULTI_THREADING
    validate(threadId != EXCEPT_THREAD_ID_FUNC(), NOTHING);
    if (threadId == -1)
        threadId = EXCEPT_THREAD_ID_FUNC();

    EXCEPT_THREAD_MUTEX_FUNC(1);
    if (pContextHash != NULL)
    {
        Context * pC;
        
        pC = HashLookup(pContextHash, threadId);
        if (pC != NULL)
        {
            ExceptRestoreHandlers(pC);
            LifoDestroyData(pC->exStack);
            if (pC->pEx->checkList != NULL)
                ListDestroyData(pC->pEx->checkList);
            free(HashRemove(pContextHash, threadId));
        }
    }    
    EXCEPT_THREAD_MUTEX_FUNC(0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x1100
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
je 0x19f2
jmp 0x1a30
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x1100
movq %rax, %rcx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
je 0x1a09
jmp 0x1a2b
movq 0x6820(%rip), %rdi      # 0x8230
xorl %esi, %esi
leaq 0x36dd(%rip), %rdx      # 0x50f6
leaq 0x36f6(%rip), %rcx      # 0x5116
movl $0x2c6, %r8d            # imm = 0x2C6
callq 0x2d10
jmp 0x1ac6
cmpl $-0x1, -0x4(%rbp)
jne 0x1a3e
callq 0x1100
movl %eax, -0x4(%rbp)
movl $0x1, %edi
callq 0x1870
cmpq $0x0, 0x67e8(%rip)      # 0x8238
je 0x1abf
movq 0x67df(%rip), %rdi      # 0x8238
movl -0x4(%rbp), %esi
callq 0x30c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1abd
movq -0x10(%rbp), %rdi
callq 0x1ad0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2850
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x1c0(%rax)
je 0x1aa6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1c0(%rax), %rdi
callq 0x3520
movq 0x678b(%rip), %rdi      # 0x8238
movl -0x4(%rbp), %esi
callq 0x32f0
movq %rax, %rdi
callq 0x1040
jmp 0x1abf
xorl %edi, %edi
callq 0x1870
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptRestoreHandlers
static int ExceptRestoreHandlers(
    Context *   pC)             /* pointer to thread exception context */
{
    int restored = 0;

    EXCEPT_THREAD_MUTEX_FUNC(1);
    if (MULTI_THREADING && SHARE_HANDLERS && --numThreadsTry == 0)
    {
        signal(SIGABRT, sharedSigAbrtHandler);
        signal(SIGFPE,  sharedSigFpeHandler);
        signal(SIGILL,  sharedSigIllHandler);
        signal(SIGSEGV, sharedSigSegvHandler);
#ifdef  SIGBUS
        signal(SIGBUS,  sharedSigBusHandler);
#endif

        restored = 1;
    }
    else if (!MULTI_THREADING || !SHARE_HANDLERS)
    {
        signal(SIGABRT, pC->sigAbrtHandler);
        signal(SIGFPE,  pC->sigFpeHandler);
        signal(SIGILL,  pC->sigIllHandler);
        signal(SIGSEGV, pC->sigSegvHandler);
#ifdef  SIGBUS
        signal(SIGBUS,  pC->sigBusHandler);
#endif

        restored = 1;
    }
    EXCEPT_THREAD_MUTEX_FUNC(0);
    
    return restored;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, %edi
callq 0x1870
movl 0x678d(%rip), %eax      # 0x8280
addl $-0x1, %eax
movl %eax, 0x6784(%rip)      # 0x8280
cmpl $0x0, %eax
jne 0x1b5f
movq 0x6780(%rip), %rsi      # 0x8288
movl $0x6, %edi
callq 0x1090
movq 0x6777(%rip), %rsi      # 0x8290
movl $0x8, %edi
callq 0x1090
movq 0x676e(%rip), %rsi      # 0x8298
movl $0x4, %edi
callq 0x1090
movq 0x6765(%rip), %rsi      # 0x82a0
movl $0xb, %edi
callq 0x1090
movq 0x675c(%rip), %rsi      # 0x82a8
movl $0x7, %edi
callq 0x1090
movl $0x1, -0xc(%rbp)
jmp 0x1b61
jmp 0x1b61
xorl %edi, %edi
callq 0x1870
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptTry
void ExceptTry(
    Context *   pC,             /* pointer to thread exception context */
    char *      file,           /* source file name */
    int         line)           /* source line number */
{
    int first;
    
#if     MULTI_THREADING
    EXCEPT_THREAD_MUTEX_FUNC(1);
    if (pContextHash == NULL)
        pContextHash = HashCreate();
    EXCEPT_THREAD_MUTEX_FUNC(0);
#endif
  
    if (first = (pC == NULL))
        pC = ExceptGetContext(NULL);
    if (pC == NULL)                     /* not needed for single-threading */
        pC = ExceptCreateContext();
  
    ExceptInstallHandlers(pC);

    LifoPush(pC->exStack, pC->pEx = calloc(sizeof(Except), 1));
    pC->pEx->first = first; 
    pC->pEx->tryFile = file;
    pC->pEx->tryLine = line;
    
    ExceptPrintDebug(pC, "ExceptTry");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, %edi
callq 0x1870
cmpq $0x0, 0x6693(%rip)      # 0x8238
jne 0x1bb3
callq 0x2ee0
movq %rax, 0x6685(%rip)      # 0x8238
xorl %edi, %edi
callq 0x1870
cmpq $0x0, -0x8(%rbp)
sete %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x18(%rbp)
testb $0x1, %al
jne 0x1bd3
jmp 0x1be0
xorl %eax, %eax
movl %eax, %edi
callq 0x1810
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1bf0
callq 0x1c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ce0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1f8, %edi            # imm = 0x1F8
movl $0x1, %esi
callq 0x1080
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rax
movq %rsi, (%rax)
callq 0x28e0
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x1bc(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x1c8(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x1d0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptCreateContext
static Context * ExceptCreateContext(void)
{
    Context *   pC;

    pC = calloc(1, sizeof(Context));
    if (pC == NULL)
        fprintf(stderr, "Except internal error: out of memory.\n");
    EXCEPT_THREAD_MUTEX_FUNC(1);
    HashAdd(pContextHash, EXCEPT_THREAD_ID_FUNC(), pC);
    EXCEPT_THREAD_MUTEX_FUNC(0);
    
    ExceptPrintDebug(pC, "ExceptCreateContext");
    
    return pC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x438, %esi            # imm = 0x438
callq 0x1080
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1c9a
movq 0x636f(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x35b5(%rip), %rsi      # 0x5248
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1870
movq 0x658d(%rip), %rax      # 0x8238
movq %rax, -0x10(%rbp)
callq 0x1100
movq -0x10(%rbp), %rdi
movl %eax, %esi
movq -0x8(%rbp), %rdx
callq 0x3210
xorl %edi, %edi
callq 0x1870
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptInstallHandlers
static int ExceptInstallHandlers(
    Context *   pC)             /* pointer to thread exception context */
{
    int stored = 0;
    
    if (pC->exStack == NULL)
    {
        pC->exStack = LifoCreate();

        EXCEPT_THREAD_MUTEX_FUNC(1);
        if (MULTI_THREADING && SHARE_HANDLERS && numThreadsTry++ == 0)
        {
            sharedSigAbrtHandler = signal(SIGABRT, ExceptThrowSignal);
            sharedSigFpeHandler  = signal(SIGFPE,  ExceptThrowSignal);
            sharedSigIllHandler  = signal(SIGILL,  ExceptThrowSignal);
            sharedSigSegvHandler = signal(SIGSEGV, ExceptThrowSignal);
#ifdef  SIGBUS
            sharedSigBusHandler  = signal(SIGBUS,  ExceptThrowSignal);
#endif

            stored = 1;
        }
        else if (!MULTI_THREADING || !SHARE_HANDLERS)
        {
            pC->sigAbrtHandler = signal(SIGABRT, ExceptThrowSignal);
            pC->sigFpeHandler  = signal(SIGFPE,  ExceptThrowSignal);
            pC->sigIllHandler  = signal(SIGILL,  ExceptThrowSignal);
            pC->sigSegvHandler = signal(SIGSEGV, ExceptThrowSignal);
#ifdef  SIGBUS
            pC->sigBusHandler  = signal(SIGBUS,  ExceptThrowSignal);
#endif

            stored = 1;
        }
        EXCEPT_THREAD_MUTEX_FUNC(0);
    }

    return stored;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1dc0
callq 0x27a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, %edi
callq 0x1870
movl 0x655e(%rip), %eax      # 0x8280
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x6553(%rip)      # 0x8280
cmpl $0x0, %eax
jne 0x1db7
movl $0x6, %edi
leaq 0x9ae(%rip), %rsi       # 0x26f0
callq 0x1090
movq %rax, 0x653a(%rip)      # 0x8288
movl $0x8, %edi
leaq 0x996(%rip), %rsi       # 0x26f0
callq 0x1090
movq %rax, 0x652a(%rip)      # 0x8290
movl $0x4, %edi
leaq 0x97e(%rip), %rsi       # 0x26f0
callq 0x1090
movq %rax, 0x651a(%rip)      # 0x8298
movl $0xb, %edi
leaq 0x966(%rip), %rsi       # 0x26f0
callq 0x1090
movq %rax, 0x650a(%rip)      # 0x82a0
movl $0x7, %edi
leaq 0x94e(%rip), %rsi       # 0x26f0
callq 0x1090
movq %rax, 0x64fa(%rip)      # 0x82a8
movl $0x1, -0xc(%rbp)
jmp 0x1db9
jmp 0x1db9
xorl %edi, %edi
callq 0x1870
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptGetMessage
static char * ExceptGetMessage(void)
{
    Context *   pC = ExceptGetContext(NULL);

    ExceptPrintDebug(pC, "ExceptGetMessage");

    sprintf(pC->message, "%s: file \"%s\", line %d.",
            pC->pEx->class->name, pC->pEx->file, pC->pEx->line);

    return pC->message;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1810
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x198(%rax), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x1a8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x1b0(%rax), %r8d
leaq 0x32af(%rip), %rsi      # 0x5271
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rax
addq $0x10, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptPrintTryTrace
static void ExceptPrintTryTrace(
   FILE *       pFile)          /* stream to which is printed or NULL */
{
    Context *   pC = ExceptGetContext(NULL);
    int         n;
    
    ExceptPrintDebug(pC, "ExceptGetData");

    if (pFile == NULL)
        pFile = stderr;

#if     MULTI_THREADING
    fprintf(pFile, "%s occurred in thread %d:\n", pC->pEx->class->name,
            EXCEPT_THREAD_ID_FUNC());
#else
    fprintf(pFile, "%s occurred:\n", pC->pEx->class->name);
#endif

    for (n = 1; n <= LifoCount(pC->exStack); n++)
    {
        Except *    pEx = LifoPeek(pC->exStack, n);
        
        fprintf(pFile, "        in 'try' at %s:%d\n", pEx->tryFile, pEx->tryLine);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1810
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x203e
movq 0x5fc1(%rip), %rax      # 0x7ff8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x198(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1100
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl %eax, %ecx
leaq 0x3217(%rip), %rsi      # 0x5289
movb $0x0, %al
callq 0x10a0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2cc0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jg 0x20e2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x2ac0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x1c8(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x1d0(%rax), %ecx
leaq 0x31d4(%rip), %rsi      # 0x52a4
movb $0x0, %al
callq 0x10a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2080
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptCatch
int ExceptCatch(
    Context *   pC,             /* pointer to thread exception context */
    ClassRef    class)          /* pointer to occurred exception */
{
    ExceptPrintDebug(pC, "ExceptCatch");

    if (pC == NULL)
        pC = ExceptGetContext(NULL);

    if (pC->pEx->state == PENDING && ExceptIsDerived(pC->pEx->class, class))
        pC->pEx->state = CAUGHT;

    return pC->pEx->state == CAUGHT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2114
xorl %eax, %eax
movl %eax, %edi
callq 0x1810
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x214b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x198(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2170
cmpl $0x0, %eax
je 0x214b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x2, 0x4(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, 0x4(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptReturn
void ExceptReturn(
    Context *   pC)             /* pointer to thread exception context */
{
    ExceptPrintDebug(pC, "ExceptReturn");

    if (pC == NULL)
        pC = ExceptGetContext(NULL);

    pC->pEx->class = ReturnEvent;       /* may overrule pending exception */
    pC->pEx->state = PENDING;           /* in case of return() inside 'catch' */
    ExceptPrintDebug(pC, "longjmp(finalBuf)");
        
    LONGJMP(pC->pEx->finalBuf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2490
xorl %eax, %eax
movl %eax, %edi
callq 0x1810
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
leaq 0x5d62(%rip), %rcx      # 0x8200
movq %rcx, 0x198(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0xd0, %rdi
movl $0x1, %esi
callq 0x1070
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptCheckBegin
int ExceptCheckBegin(
    Context *   pC,             /* pointer to thread exception context */
    int *       pChecked,       /* pointer to flag if finished checking */
    char *      file,           /* name of source file where invoked */
    int         line)           /* source file line number */
{
    ExceptPrintDebug(pC, "ExceptCheckBegin");

    if (pC->pEx->checkList == NULL && !*pChecked)
    {
        pC->pEx->checkList = ListCreate();
    }
    else
    {
        if (!*pChecked)
        {
            if (ListCount(pC->pEx->checkList) == 0)
            {
                fprintf(stderr,
                        "Warning: No catch clause(s): file \"%s\", line %d.\n",
                        file, line);
            }

            ListDestroyData(pC->pEx->checkList);
            pC->pEx->checkList = NULL;
            *pChecked = 1;
        }
    }

    return *pChecked;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x1c0(%rax)
jne 0x2519
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2519
callq 0x3420
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x1c0(%rax)
jmp 0x258a
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2588
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x1c0(%rax), %rdi
callq 0x43f0
cmpl $0x0, %eax
jne 0x2559
movq 0x5ab7(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x2beb(%rip), %rsi      # 0x513d
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x1c0(%rax), %rdi
callq 0x3520
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x1c0(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x258a
movq -0x10(%rbp), %rax
movl (%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Except.c
// Function: ExceptThrowSignal
static void ExceptThrowSignal(
    int         number)         /* signal number */
{
    ClassRef    class;

    ExceptPrintDebug(pC, "ExceptThrowSignal");

    switch (number)
    {
    case SIGABRT: class = AbnormalTermination; break;
    case SIGFPE:  class = ArithmeticException; break;
    case SIGILL:  class = IllegalInstruction;  break;
    case SIGSEGV: class = SegmentationFault;   break;
#ifdef  SIGBUS
    case SIGBUS:  class = BusError;            break;
#endif
    }

    signal(number, ExceptThrowSignal);

    class->signalNumber = number;       /* redundant after first time */
        
    ExceptThrow(NULL, class, NULL, "?", 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x7, %eax
ja 0x275f
movq -0x18(%rbp), %rax
leaq 0x292d(%rip), %rcx      # 0x5044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5a39(%rip), %rax      # 0x8160
movq %rax, -0x10(%rbp)
jmp 0x275f
leaq 0x5a4c(%rip), %rax      # 0x8180
movq %rax, -0x10(%rbp)
jmp 0x275f
leaq 0x5a5f(%rip), %rax      # 0x81a0
movq %rax, -0x10(%rbp)
jmp 0x275f
leaq 0x5a72(%rip), %rax      # 0x81c0
movq %rax, -0x10(%rbp)
jmp 0x275f
leaq 0x5a85(%rip), %rax      # 0x81e0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
leaq -0x79(%rip), %rsi       # 0x26f0
callq 0x1090
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq 0x2ae8(%rip), %rcx      # 0x526f
xorl %r8d, %r8d
movq %rdx, %rdi
callq 0x1dd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Lifo.c
// Function: LifoCreate
Lifo * LifoCreate(void)
{
    Lifo *      pLifo;

    pLifo = malloc(sizeof(Lifo));
    pLifo->pObjects = malloc(INIT_SIZE * sizeof(void *));
    pLifo->size = INIT_SIZE;
    pLifo->pointer = 0;
    return pLifo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x10d0
movq %rax, -0x8(%rbp)
movl $0x100, %edi            # imm = 0x100
callq 0x10d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x20, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Lifo.c
// Function: LifoDestroyData
void LifoDestroyData(
    Lifo *      pLifo)          /* pointer to LIFO buffer */
{
    assert(pLifo != NULL);

    while(pLifo->pointer > 0)
        free(pLifo->pObjects[pLifo->pointer--]);

    free(pLifo->pObjects);
    free(pLifo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2865
jmp 0x288a
leaq 0x59c4(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x2a53(%rip), %rdx      # 0x52cb
leaq 0x2a5a(%rip), %rcx      # 0x52d9
movl $0x67, %r8d
callq 0x2d10
jmp 0x288c
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jle 0x28ba
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdx
movl 0xc(%rdx), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, 0xc(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
jmp 0x288c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)