LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::packImageData[abi:cxx11]()
std::string packImageData() {
		std::stringstream baos;
		
		{
            for (int y = 0; y < height_; y++) {
                if (pixels[y] == 0) {
                    addPhotonRLE(baos, true, width_);
                } else {
                    char current = PhotonDot::OFF;
                    int length = 0;
                    for (int x = 0; x < width_; x++) {
						char next = iArray[y][x];
                        if (next != current) {
                            if (length > 0) {
                                addPhotonRLE(baos, current == PhotonDot::OFF, length);
                            }
                            current = next;
                            length = 1;
                        } else {
                            length++;
                        }
                    }
                    if (length > 0) {
                        addPhotonRLE(baos, current == PhotonDot::OFF, length);
                    }
                }
            }

            return baos.str();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3160
xorl %r15d, %r15d
pushq $0x1
popq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jge 0xb309
movq 0x28(%r14), %rax
cmpl $0x0, (%rax,%r15,4)
je 0xb2ec
xorl %ebx, %ebx
movq %r15, -0x38(%rbp)
imulq $0x18, %r15, %r15
xorl %eax, %eax
xorl %ecx, %ecx
movslq (%r14), %rdx
cmpq %rdx, %rbx
jge 0xb2cc
movq 0x10(%r14), %rdx
movq (%rdx,%r15), %rdx
movb (%rdx,%rbx), %r13b
cmpb %al, %r13b
jne 0xb2a2
incl %ecx
movl %eax, %r13d
jmp 0xb2c4
testl %ecx, %ecx
jle 0xb2c1
xorl %edx, %edx
testb %al, %al
sete %dl
movq %r14, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xb56c
movl %r12d, %ecx
jmp 0xb2c4
movl %r12d, %ecx
incq %rbx
movl %r13d, %eax
jmp 0xb282
testl %ecx, %ecx
movq -0x38(%rbp), %r15
jle 0xb301
xorl %edx, %edx
testb %al, %al
sete %dl
movq %r14, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xb56c
jmp 0xb301
movl (%r14), %ecx
movq %r14, %rdi
leaq -0x1b0(%rbp), %rsi
movl %r12d, %edx
callq 0xb56c
incq %r15
jmp 0xb25c
leaq -0x1a8(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x3370
leaq -0x1c0(%rbp), %rdi
callq 0x3170
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb343
jmp 0xb343
jmp 0xb343
movq %rax, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_c_makefile_star2_O2/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::setIslands(std::vector<std::vector<bool, std::allocator<bool>>, std::allocator<std::vector<bool, std::allocator<bool>>>>&)
int setIslands(std::vector<photoncpp::BitSet> & islandRows) {
        int islands = 0;
        for (int y = 0; y < height_; y++) {
			photoncpp::BitSet bitSet;
            if (rowIslands[y] > 0) {
                for (int x = 0; x < width_; x++) {
                    if (iArray[y][x] == PhotonDot::ISLAND) {
						bitSet[x] = true;
                    }
                }
            }
            islandRows.push_back(bitSet);
            islands += rowIslands[y];
        }
        return islands;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
leaq -0x60(%rbp), %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
movslq 0x4(%r14), %rax
cmpq %rax, %rbx
jge 0xb411
movl %r12d, -0x2c(%rbp)
andq $0x0, -0x60(%rbp)
andl $0x0, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
andl $0x0, -0x48(%rbp)
andq $0x0, -0x40(%rbp)
movq 0x40(%r14), %rax
xorl %ecx, %ecx
cmpl %ecx, (%rax,%rbx,4)
jle 0xb3e9
imulq $0x18, %rbx, %r12
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0xb3e9
movq 0x10(%r14), %rax
movq (%rax,%r12), %rax
cmpb $0x2, (%rax,%r13)
jne 0xb3e4
movq %r15, %rdi
movq %r13, %rsi
callq 0xb63a
orq %rdx, (%rax)
incq %r13
jmp 0xb3bf
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0xb65c
movq 0x40(%r14), %rax
movl -0x2c(%rbp), %r12d
addl (%rax,%rbx,4), %r12d
movq %r15, %rdi
callq 0x9e50
incq %rbx
jmp 0xb389
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb425
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x9e50
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_c_makefile_star2_O2/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::add(std::ostream&, char, int)
void add(std::ostream & baos, char current, int length) {
        if (length < 32) {
			std::vector<char> data(1, 0);
            data[0] = (char) ((current << 5) | (length & 0x1f));
            baos.write(data.data(), data.size());
        } else {
			std::vector<char> data(2, 0);
            data[0] = (char) (0x80 | (current << 5) | (length >> 8 & 0x00FF));
            data[1] = (char) (length & 0x00FF);
            baos.write(data.data(), data.size());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %rbx
leaq -0x1a(%rbp), %rdx
cmpl $0x1f, %ecx
jg 0xb496
movb $0x0, (%rdx)
leaq -0x38(%rbp), %rdi
pushq $0x1
popq %rsi
leaq -0x19(%rbp), %rcx
callq 0xb50e
movzbl %r15b, %eax
shll $0x5, %eax
andl $0x1f, %r14d
orl %eax, %r14d
movq -0x38(%rbp), %rax
movb %r14b, (%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x32a0
jmp 0xb4dc
movb $0x0, (%rdx)
leaq -0x38(%rbp), %rdi
pushq $0x2
popq %rsi
leaq -0x19(%rbp), %rcx
callq 0xb50e
movzbl %r15b, %eax
shll $0x5, %eax
movl %r14d, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
orb $-0x80, %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rax
movb %r14b, 0x1(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x32a0
leaq -0x38(%rbp), %rdi
callq 0x9062
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb4f2
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x9062
jmp 0xb505
jmp 0xb502
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_c_makefile_star2_O2/0x3f00[P]PhotonCpp/./PhotonLayer.h
// Function: PhotonLayer::addPhotonRLE(std::ostream&, bool, int)
void addPhotonRLE(std::ostream & baos, bool off, int length) {
		std::vector<char> data({ 0 });
        while (length>0) {
            int lineLength = std::min(length, 125); // max storage length of 0x7D (125) ?? Why not 127?
            data[0] = (char) ((off ? 0x00: 0x80) | (lineLength & 0x7f));
            baos.write(data.data(), data.size());
            length -= lineLength;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %r15d
movq %rsi, %r14
leaq -0x2a(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x48(%rbp), %rdi
pushq $0x1
popq %rdx
leaq -0x29(%rbp), %rcx
callq 0x9814
xorb $0x1, %r15b
movzbl %r15b, %r15d
shll $0x7, %r15d
pushq $0x7d
popq %r12
testl %ebx, %ebx
jle 0xb5de
cmpl $0x7d, %ebx
movl %r12d, %r13d
cmovbl %ebx, %r13d
movl %r13d, %eax
orl %r15d, %eax
movq -0x48(%rbp), %rcx
movb %al, (%rcx)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
subq %rsi, %rdx
movq %r14, %rdi
callq 0x32a0
subl %r13d, %ebx
jmp 0xb5ac
leaq -0x48(%rbp), %rdi
callq 0x9062
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x9062
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_c_makefile_star2_O2/0x3f00[P]PhotonCpp/./PhotonOutputStream.h
// Function: PhotonOutputStream::writeInt(int)
void writeInt(int v) {
		outputStream_.put(0xFF & v);
		outputStream_.put(0xFF & (v >> 8));
		outputStream_.put(0xFF & (v >> 16));
		outputStream_.put(0xFF & (v >> 24));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
movsbl %bl, %esi
callq 0x3040
movq (%r14), %rdi
movl %ebx, %eax
shrl $0x8, %eax
movsbl %al, %esi
callq 0x3040
movq (%r14), %rdi
movl %ebx, %eax
shrl $0x10, %eax
movsbl %al, %esi
callq 0x3040
movq (%r14), %rdi
sarl $0x18, %ebx
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3040
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_create
void test_create(void) {
	// Δημιουργούμε μια κενή λίστα με NULL δείκτη συνάρτησης delete_value
	List list = list_create(NULL);
	list_set_destroy_value(list, NULL);

	// Ελέγχουμε ότι δεν απέτυχε η malloc στην λίστα, και ότι
	// αρχικοποιείται με μέγεθος 0 (δηλαδή χωρίς κόμβους)
	TEST_ASSERT(list != NULL);
	TEST_ASSERT(list_size(list) == 0);

	list_destroy(list);
}

// Assembly:
pushq %rbx
xorl %edi, %edi
callq 0x4594
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x46b7
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x1892(%rip), %rsi      # 0x5318
leaq 0x1b0d(%rip), %rcx      # 0x559a
leaq 0x1893(%rip), %r8       # 0x5327
pushq $0x14
popq %rdx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3ade
movq %rbx, %rdi
callq 0x45cc
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x185f(%rip), %rsi      # 0x5318
leaq 0x1ada(%rip), %rcx      # 0x559a
leaq 0x186d(%rip), %r8       # 0x5334
pushq $0x15
popq %rdx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3ade
movq %rbx, %rdi
popq %rbx
jmp 0x46c0
callq 0x2bb0
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_find
void test_find(void) {
	List list = list_create(NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					

	// Εισάγουμε δοκιμαστικές τιμές στον πίνακα, για να ελέγξουμε την test_find
	for (int i = 0; i < N; i++) {
		array[i] = i;
		list_insert_next(list, LIST_BOF, &array[i]);
	}

	// Εύρεση όλων των στοιχείων
	for (int i = 0; i < N; i++) {
		int* value = list_find(list, &i, compare_ints); 
		TEST_ASSERT(value == &array[i]);
	}

	// Δοκιμάζουμε, για μια τυχαία τιμή που δεν μπορεί πιθανώς να υπάρχει στην λίστα,
	// αν η list_find γυρνάει σωστά NULL pointer
	int not_exists = -1;
	TEST_ASSERT(list_find(list, &not_exists, compare_ints) == NULL);

	list_destroy(list);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x4594
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r14
movq %rax, %r15
cmpq $0x3e8, %r12            # imm = 0x3E8
je 0x3e67
movl %r12d, (%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x45d0
incq %r12
addq $0x4, %r15
jmp 0x3e45
leaq 0x14aa(%rip), %r13      # 0x5318
leaq 0x1725(%rip), %rbp      # 0x559a
leaq 0x15e3(%rip), %r15      # 0x545f
pushq $0x7d
popq %r12
xorl %eax, %eax
movl %eax, (%rsp)
cmpl $0x3e8, %eax            # imm = 0x3E8
jge 0x3ecd
movq %rbx, %rdi
movq %rsp, %rsi
leaq -0x81(%rip), %rdx       # 0x3e18
callq 0x4676
movslq (%rsp), %rcx
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
movq %r13, %rsi
movl %r12d, %edx
movq %rbp, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3f31
movl (%rsp), %eax
incl %eax
jmp 0x3e82
leaq 0x4(%rsp), %rsi
orl $-0x1, (%rsi)
leaq -0xc4(%rip), %rdx       # 0x3e18
movq %rbx, %rdi
callq 0x4676
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0x1424(%rip), %rsi      # 0x5318
leaq 0x169f(%rip), %rcx      # 0x559a
leaq 0x1570(%rip), %r8       # 0x5472
movl $0x83, %edx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3f31
movq %rbx, %rdi
callq 0x46c0
movq %r14, %rdi
callq 0x2290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2bb0
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/ADTList_test.c
// Function: test_find_node
void test_find_node(void) {
	List list = list_create(NULL);

	// Εισαγωγή τιμών στον πίνακα
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					

	for (int i = 0; i < N; i++) {
		array[i] = i;
		list_insert_next(list, LIST_BOF, &array[i]);
	}

	// Ξεκινάμε από την αρχή της λίστας
	ListNode node = list_first(list);

	for (int i = N - 1; i >= 0; i--) {
		// Ελέγχουμε ότι η list_find_node βρίσκει σωστά τον πρώτο κόμβο με value τον δείκτη &array[i].
		// Σε αυτή την λίστα, δοκιμάζουμε ότι ο πρώτος κόμβος περιέχει τον δείκτη &array[N - 1], 
		// o δεύτερος τον &array[998] κοκ
		ListNode found_node = list_find_node(list, &i, compare_ints); 
		TEST_ASSERT(found_node == node);
		TEST_ASSERT(list_node_value(list, found_node) == &array[i]);

		// Προχωράμε στον επόμενο κόμβο για να προσπελάσουμε όλη την λίστα
		node = list_next(list, node);
	}

	list_destroy(list);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x4594
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r14
movq %rax, %r15
cmpq $0x3e8, %r12            # imm = 0x3E8
je 0x3f80
movl %r12d, (%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x45d0
incq %r12
addq $0x4, %r15
jmp 0x3f5e
movq %rbx, %rdi
callq 0x4701
movq %rax, %r15
movl $0x3e7, %eax            # imm = 0x3E7
leaq 0x1381(%rip), %rbp      # 0x5318
leaq 0x15fc(%rip), %r12      # 0x559a
movl %eax, 0x4(%rsp)
testl %eax, %eax
js 0x403a
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
leaq -0x1a1(%rip), %rdx      # 0x3e18
callq 0x468b
movq %rax, %r13
xorl %edi, %edi
cmpq %r15, %rax
sete %dil
movq %rbp, %rsi
movl $0x9e, %edx
movq %r12, %rcx
leaq 0x14c9(%rip), %r8       # 0x54a5
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x4059
movq %rbx, %rdi
movq %r13, %rsi
callq 0x473f
movslq 0x4(%rsp), %rcx
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rcx, %rax
sete %dil
movq %rbp, %rsi
movl $0x9f, %edx
movq %r12, %rcx
leaq 0x14a2(%rip), %r8       # 0x54b8
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x4059
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4716
movq %rax, %r15
movl 0x4(%rsp), %eax
decl %eax
jmp 0x3f9e
movq %rbx, %rdi
callq 0x46c0
movq %r14, %rdi
callq 0x2290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2bb0
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Test.c
// Function: t1
int t1(void)
{
    try
    {
        return(6);
    }
    catch (Throwable, e)
    {
        printf("%s\n", e->getMessage());
    }
    finally;
    return(7);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xaff6(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x7193(%rip), %r14      # 0xa418
pushq $0x6f
popq %rdx
movq %r14, %rsi
callq 0x14e8
leaq 0xb059(%rip), %r15      # 0xe2f0
leaq 0xae22(%rip), %r12      # 0xe0c0
pushq $0x1
popq %r13
movq (%rbp), %rdi
callq 0x1290
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
pushq $0x6f
popq %rcx
callq 0x1b23
testl %eax, %eax
je 0x32e3
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x32e3
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x3433
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
pushq $0x73
popq %r8
callq 0x1bb7
testl %eax, %eax
je 0x333e
movq (%rbx), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x333e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1867
testl %eax, %eax
je 0x333e
movq 0x8(%rbx), %rdi
movl %r13d, %esi
callq 0x1f02
movq (%rbx), %rcx
movl $0x2, 0x1b8(%rcx)
callq *0x1e0(%rax)
movq %rax, %rdi
callq 0x1070
cmpl $0x0, 0xafab(%rip)      # 0xe2f0
je 0x32a2
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x337c
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x337c
movq (%rbx), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x32a2
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x33b4
movq (%rbp), %rdi
callq 0x18d5
testl %eax, %eax
je 0x33d6
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x33b4
jmp 0x3392
movq (%rbp), %rdi
callq 0x125c
pushq $0x7
popq %r14
cmpl $-0x1, %eax
je 0x349e
movq (%rbp), %rdi
leaq 0x7021(%rip), %rdx      # 0xa418
pushq $0x78
popq %rcx
movl $0xc8, %esi
callq 0x2112
movq %rax, %rbx
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x3495
movq %rbx, %rdi
callq 0x1040
jmp 0x349e
movq (%rbx), %rax
movl $0x1, 0x1b8(%rax)
movq %rbx, %rdi
callq 0x125c
pushq $0x6
popq %rbp
cmpl $-0x1, %eax
je 0x34ab
leaq 0x6fc1(%rip), %rdx      # 0xa418
pushq $0x71
popq %rcx
movq %rbx, %rdi
movl $0xc8, %esi
callq 0x2112
movq %rax, %r14
movq %rbx, %rdi
callq 0x1290
movq (%rax), %rax
movq %r14, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1130
testl %eax, %eax
je 0x34a3
movq %r14, %rdi
callq 0x1040
jmp 0x34ab
movq (%rbp), %rdi
callq 0x1aec
movl %r14d, %eax
jmp 0x34ad
movq %rbx, %rdi
callq 0x1aec
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Test.c
// Function: t2
int t2(void)
{
    try
    {
        return(6);
    }
    finally
    {
        return(7);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xada2(%rip), %r13      # 0xe270
movq (%r13), %rdi
leaq 0x6f3f(%rip), %r14      # 0xa418
pushq $0x7d
popq %rbp
movq %r14, %rsi
movl %ebp, %edx
callq 0x14e8
leaq 0xae07(%rip), %r15      # 0xe2f4
pushq $0x1
popq %r12
movq (%r13), %rdi
callq 0x1290
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x1b23
testl %eax, %eax
je 0x3531
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x3531
addq $0x8, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
je 0x3620
cmpl $0x0, 0xadbc(%rip)      # 0xe2f4
je 0x34f1
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x3568
addq $0xd0, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
jne 0x3568
movq (%rbx), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x34f1
movq (%r13), %rdi
callq 0x1290
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
pushq $0x6
popq %rbx
movq (%r13), %rdi
callq 0x1290
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x35a7
movq (%r13), %rdi
callq 0x18d5
testl %eax, %eax
je 0x3682
movq (%r13), %rdi
callq 0x1290
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jle 0x3581
movq (%r13), %rdi
callq 0x125c
pushq $0x7
popq %rbp
cmpl $-0x1, %eax
je 0x3694
movq (%r13), %rdi
leaq 0x6e31(%rip), %rdx      # 0xa418
movl $0xc8, %esi
movl $0x83, %ecx
callq 0x2112
movq %rax, %rbx
movq (%r13), %rdi
callq 0x1290
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x3686
movq %rbx, %rdi
jmp 0x367b
movq (%rbx), %rax
movl $0x1, 0x1b8(%rax)
movq %rbx, %rdi
callq 0x125c
pushq $0x6
popq %rbp
cmpl $-0x1, %eax
je 0x3694
leaq 0x6dd4(%rip), %rdx      # 0xa418
pushq $0x7f
popq %rcx
movq %rbx, %rdi
movl $0xc8, %esi
callq 0x2112
movq %rax, %r14
movq %rbx, %rdi
callq 0x1290
movq (%rax), %rax
movq %r14, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1130
testl %eax, %eax
je 0x368c
movq %r14, %rdi
callq 0x1040
jmp 0x3694
movl %ebx, %eax
jmp 0x3696
movq (%r13), %rdi
jmp 0x368f
movq %rbx, %rdi
callq 0x1aec
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Test.c
// Function: t3
int t3(void)
{
    try
    {
        assert(0);
    }
    catch (FailedAssertion, e)
    {
        return(8);
    }
    finally;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xabb9(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x6d56(%rip), %r14      # 0xa418
movl $0x89, %edx
movq %r14, %rsi
callq 0x14e8
leaq 0xac22(%rip), %r15      # 0xe2f8
leaq 0xaa43(%rip), %r12      # 0xe120
pushq $0x1
popq %r13
movq (%rbp), %rdi
callq 0x1290
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x89, %ecx
callq 0x1b23
testl %eax, %eax
je 0x3720
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x3720
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x375b
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movl $0x8d, %r8d
callq 0x1bb7
testl %eax, %eax
je 0x3782
movq (%rbx), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x3782
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1867
testl %eax, %eax
je 0x3782
jmp 0x381e
movq (%rbx), %rax
movl $0x1, 0x1b8(%rax)
movq %rbx, %rdi
xorl %esi, %esi
leaq 0x6bbe(%rip), %rdx      # 0xa332
movq %r14, %rcx
movl $0x8b, %r8d
callq 0x2030
cmpl $0x0, 0xab6f(%rip)      # 0xe2f8
je 0x36e1
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x37c0
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x37c0
movq (%rbx), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x36e1
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x37fc
movq (%rbp), %rdi
callq 0x18d5
testl %eax, %eax
je 0x3893
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x37fc
jmp 0x37d6
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1f02
movq (%rbx), %rax
movl $0x2, 0x1b8(%rax)
movq %rbx, %rdi
callq 0x125c
cmpl $-0x1, %eax
je 0x3893
leaq 0x6bcd(%rip), %rdx      # 0xa418
movq %rbx, %rdi
movl $0xc8, %esi
movl $0x8f, %ecx
callq 0x2112
movq %rax, %r14
movq %rbx, %rdi
callq 0x1290
movq (%rax), %rax
movq %r14, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1130
testl %eax, %eax
je 0x388b
movq %r14, %rdi
callq 0x1040
jmp 0x3893
movq %rbx, %rdi
callq 0x1aec
pushq $0x8
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Test.c
// Function: t4
int t4(void)
{
    try
    {
        assert(0);
    }
    catch (FailedAssertion, e)
    {
        return(8);
    }
    finally
    {
        return(9);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xa9b9(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x6b56(%rip), %r14      # 0xa418
movl $0x96, %edx
movq %r14, %rsi
callq 0x14e8
leaq 0xaa26(%rip), %r15      # 0xe2fc
leaq 0xa843(%rip), %r12      # 0xe120
pushq $0x1
popq %r13
movq (%rbp), %rdi
callq 0x1290
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x96, %ecx
callq 0x1b23
testl %eax, %eax
je 0x3920
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x3920
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x395b
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movl $0x9a, %r8d
callq 0x1bb7
testl %eax, %eax
je 0x3982
movq (%rbx), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x3982
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1867
testl %eax, %eax
je 0x3982
jmp 0x3a8c
movq (%rbx), %rax
movl $0x1, 0x1b8(%rax)
movq %rbx, %rdi
xorl %esi, %esi
leaq 0x69be(%rip), %rdx      # 0xa332
movq %r14, %rcx
movl $0x98, %r8d
callq 0x2030
cmpl $0x0, 0xa973(%rip)      # 0xe2fc
je 0x38e1
movq (%rbx), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x39c0
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x39c0
movq (%rbx), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x38e1
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
pushq $0x8
popq %rbx
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x39ff
movq (%rbp), %rdi
callq 0x18d5
testl %eax, %eax
je 0x3a85
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jle 0x39d9
movq (%rbp), %rdi
callq 0x125c
pushq $0x9
popq %r14
cmpl $-0x1, %eax
je 0x3b05
movq (%rbp), %rdi
leaq 0x69d8(%rip), %rdx      # 0xa418
movl $0xc8, %esi
movl $0xa0, %ecx
callq 0x2112
movq %rax, %rbx
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x3afc
movq %rbx, %rdi
callq 0x1040
jmp 0x3b05
movl %ebx, %eax
jmp 0x3b14
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1f02
movq (%rbx), %rax
movl $0x2, 0x1b8(%rax)
movq %rbx, %rdi
callq 0x125c
pushq $0x8
popq %rbp
cmpl $-0x1, %eax
je 0x3b12
leaq 0x695c(%rip), %rdx      # 0xa418
movq %rbx, %rdi
movl $0xc8, %esi
movl $0x9c, %ecx
callq 0x2112
movq %rax, %r14
movq %rbx, %rdi
callq 0x1290
movq (%rax), %rax
movq %r14, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1130
testl %eax, %eax
je 0x3b0a
movq %r14, %rdi
callq 0x1040
jmp 0x3b12
movq (%rbp), %rdi
callq 0x1aec
movl %r14d, %eax
jmp 0x3b14
movq %rbx, %rdi
callq 0x1aec
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Test.c
// Function: recurse
void recurse(int x)
{
    printf("recurse(%d)\n", x);

    try
    {
        if (x == 0)
            *((int *)0) = 0;
        recurse(x - 1);
    }
    finally
        printf("%d, ", x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x5f9a(%rip), %rdi      # 0xa42e
xorl %eax, %eax
movl %ebx, %esi
callq 0x1080
leaq 0x9dcc(%rip), %r15      # 0xe270
movq (%r15), %rdi
leaq 0x5f6a(%rip), %rsi      # 0xa418
movl $0x2cd, %ebp            # imm = 0x2CD
movl %ebp, %edx
callq 0x14e8
movl %ebx, %eax
decl %eax
movl %eax, 0x4(%rsp)
leaq 0x9e4f(%rip), %r12      # 0xe318
pushq $0x1
popq %r13
movq (%r15), %rdi
callq 0x1290
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
leaq 0x5f33(%rip), %rdx      # 0xa418
movl %ebp, %ecx
callq 0x1b23
testl %eax, %eax
je 0x4522
movq (%r14), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x4522
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x4522
movq (%r14), %rax
movl $0x1, 0x1b8(%rax)
movl 0x4(%rsp), %edi
callq 0x4480
cmpl $0x0, 0x9def(%rip)      # 0xe318
je 0x44cd
movq (%r14), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x455c
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x455c
movq (%r14), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x44cd
movq (%r15), %rdi
callq 0x1290
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
leaq 0x5ec3(%rip), %r14      # 0xa43b
xorl %ebp, %ebp
movq (%r15), %rdi
callq 0x1290
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x45a8
movq (%r15), %rdi
callq 0x18d5
testl %eax, %eax
jne 0x45a8
jmp 0x45c9
movl %ebp, %eax
movq %r14, %rdi
movl %ebx, %esi
callq 0x1080
movq (%r15), %rdi
callq 0x1290
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x459c
jmp 0x457a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Test.c
// Function: main
int main(void)
{
    TestThrow();
    CheckStack();

    TestReturn();
    CheckStack();

    TestMemory();
    CheckStack();

    TestNesting();
    CheckStack();

    TestAssert();
    CheckStack();

    TestValidate();
    CheckStack();

    TestCheck();
    CheckStack();

    TestRecursion();
    CheckStack();

    TestSignal();
    CheckStack();

    printf("\nREADY\n\n");
}

// Assembly:
pushq %rax
callq 0x46ae
callq 0x45d8
callq 0x4fe9
callq 0x45d8
callq 0x52f3
callq 0x45d8
callq 0x71a6
callq 0x45d8
callq 0x5850
callq 0x45d8
leaq 0x6341(%rip), %rdi      # 0xa981
callq 0x1070
movl 0x9c15(%rip), %esi      # 0xe260
leal 0x1(%rsi), %eax
movl %eax, 0x9c0c(%rip)      # 0xe260
leaq 0x605f(%rip), %rdi      # 0xa6ba
xorl %eax, %eax
callq 0x1080
leaq 0x6066(%rip), %rdi      # 0xa6cf
pushq $0x1b
popq %rsi
xorl %eax, %eax
callq 0x1080
pushq $0xa
popq %rdi
callq 0x1050
callq 0x45d8
callq 0x5de7
callq 0x45d8
callq 0x676f
callq 0x45d8
callq 0x693e
callq 0x45d8
leaq 0x61d8(%rip), %rdi      # 0xa87d
callq 0x1070
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Test.c
// Function: TestRecursion
static void TestRecursion(void)
{
    printf("\nRECURSION TESTS ---------------------------------------\n\n");

    printf("-->%2d: Hits a run-time exception after 10 levels?\n", testNum++);
    try
        recurse(10);
    catch (RuntimeException, e)
        printf("%s\n", e->getMessage());
    finally;
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4274(%rip), %rdi      # 0xa9f5
callq 0x1070
movl 0x7ad4(%rip), %esi      # 0xe260
movl %esi, %eax
incl %eax
movl %eax, 0x7aca(%rip)      # 0xe260
leaq 0x4020(%rip), %rdi      # 0xa7bd
xorl %eax, %eax
callq 0x1080
leaq 0x7ac5(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x3c62(%rip), %rbx      # 0xa418
movl $0x2dc, %edx            # imm = 0x2DC
movq %rbx, %rsi
callq 0x14e8
leaq 0x7bea(%rip), %r14      # 0xe3b4
leaq 0x796f(%rip), %r15      # 0xe140
pushq $0x1
popq %r13
movq (%rbp), %rdi
callq 0x1290
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2dc, %ecx            # imm = 0x2DC
callq 0x1b23
testl %eax, %eax
je 0x6815
movq (%r12), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x6815
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x6877
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl $0x2de, %r8d            # imm = 0x2DE
callq 0x1bb7
testl %eax, %eax
je 0x688d
movq (%r12), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x688d
movq %r12, %rdi
movq %r15, %rsi
callq 0x1867
testl %eax, %eax
je 0x688d
movq 0x8(%r12), %rdi
movl %r13d, %esi
callq 0x1f02
movq (%r12), %rcx
movl $0x2, 0x1b8(%rcx)
callq *0x1e0(%rax)
movq %rax, %rdi
callq 0x1070
jmp 0x688d
movq (%r12), %rax
movl $0x1, 0x1b8(%rax)
pushq $0xa
popq %rdi
callq 0x4480
cmpl $0x0, 0x7b20(%rip)      # 0xe3b4
je 0x67d5
movq (%r12), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x68cd
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x68cd
movq (%r12), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x67d5
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x6905
movq (%rbp), %rdi
callq 0x18d5
testl %eax, %eax
je 0x6927
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x6905
jmp 0x68e3
pushq $0xa
popq %rdi
callq 0x1050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Test.c
// Function: t5
static void t5(void)
{
    try
    {
        raise(SIGABRT);
    }
    catch (SegmentationFault, e);
    catch (IllegalInstruction, e);
    finally;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x4f87(%rip), %rbp      # 0xe270
movq (%rbp), %rdi
leaq 0x1124(%rip), %rbx      # 0xa418
movl $0xfe, %edx
movq %rbx, %rsi
callq 0x14e8
leaq 0x50c4(%rip), %r14      # 0xe3cc
leaq 0x4eb1(%rip), %r15      # 0xe1c0
pushq $0x1
popq %r12
movq (%rbp), %rdi
callq 0x1290
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0xfe, %ecx
callq 0x1b23
testl %eax, %eax
je 0x9357
movq (%r13), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x9357
addq $0x8, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
je 0x93e9
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl $0x102, %r8d            # imm = 0x102
callq 0x1bb7
testl %eax, %eax
je 0x938e
movq (%r13), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x938e
movq %r13, %rdi
movq %r15, %rsi
callq 0x1867
testl %eax, %eax
jne 0x93cd
movq %r13, %rdi
movq %r14, %rsi
leaq 0x4e05(%rip), %rdx      # 0xe1a0
movq %rbx, %rcx
movl $0x103, %r8d            # imm = 0x103
callq 0x1bb7
testl %eax, %eax
je 0x93ff
movq (%r13), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x93ff
movq %r13, %rdi
leaq 0x4ddc(%rip), %rsi      # 0xe1a0
callq 0x1867
testl %eax, %eax
je 0x93ff
movq 0x8(%r13), %rdi
movl %r12d, %esi
callq 0x1f02
movq (%r13), %rax
movl $0x2, 0x1b8(%rax)
jmp 0x93ff
movq (%r13), %rax
movl $0x1, 0x1b8(%rax)
pushq $0x6
popq %rdi
callq 0x1030
cmpl $0x0, 0x4fc6(%rip)      # 0xe3cc
je 0x9313
movq (%r13), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x943f
addq $0xd0, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
jne 0x943f
movq (%r13), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x9313
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x9477
movq (%rbp), %rdi
callq 0x18d5
testl %eax, %eax
je 0x9499
movq (%rbp), %rdi
callq 0x1290
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x9477
jmp 0x9455
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: zerocore
void
zerocore(void)
{
	Addr a;
	for(a = 0; a < MAXMEM; a++)
		deposit(a, 0);
	putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpw $0x800, %bx             # imm = 0x800
je 0x2d79
movzwl %bx, %edi
xorl %esi, %esi
callq 0x3dc4
incl %ebx
jmp 0x2d64
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: deposit
void
deposit(Addr a, Word w)
{
	WWI *ww = &ww1;
	if(MS_SELECT(a))
		ww->core[a] = w;
	else if(IS_FF(a))
		ww->ffs[a & 037] = w;
	else
		ww->tss[a & 037] = w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpw $0x20, %di
jae 0x3dea
movl 0xa814(%rip), %eax      # 0xe5e8
btl %edi, %eax
movzwl %di, %eax
leaq 0xa7ef(%rip), %rcx      # 0xe5d0
jae 0x3dfe
movw %si, 0x1c(%rcx,%rax,2)
jmp 0x3e03
movzwl %di, %eax
leaq 0xa7dc(%rip), %rcx      # 0xe5d0
movw %si, 0x9c(%rcx,%rax,2)
jmp 0x3e03
movw %si, 0x5c(%rcx,%rax,2)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: examine
Word
examine(Addr a)
{
	WWI *ww = &ww1;
	if(MS_SELECT(a))
		return ww->core[a];
	else if(IS_FF(a))
		return ww->ffs[a & 037];
	else
		return ww->tss[a & 037];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpw $0x20, %di
jae 0x3e2e
movl 0xa7d3(%rip), %eax      # 0xe5e8
btl %edi, %eax
movzwl %di, %eax
leaq 0xa7ae(%rip), %rcx      # 0xe5d0
jae 0x3e44
leaq (%rcx,%rax,2), %rax
addq $0x1c, %rax
jmp 0x3e4c
movzwl %di, %eax
leaq 0xa798(%rip), %rcx      # 0xe5d0
leaq (%rcx,%rax,2), %rax
addq $0x9c, %rax
jmp 0x3e4c
leaq (%rcx,%rax,2), %rax
addq $0x5c, %rax
movzwl (%rax), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: depositreg
void
depositreg(int a, Word w)
{
	switch(a){
	case REG_PC: ww1.pc = w & ADDRMASK; break;
	case REG_AC: ww1.ac = w & WORDMASK; break;
	case REG_A: ww1.ar = w & WORDMASK; break;
	case REG_B: ww1.br = w & WORDMASK; break;
	case REG_SAM:
		ww1.ac0_carry = ww1.sam = 0;
		if(w == 1)
			ww1.ac0_carry = 1;
		else if(w == 0177776)
			ww1.sam = 1;
		break;
	default:
		// Set toggle switch storage
		if(a < 32)
			ww1.tss[a] = w;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x20(%rdi), %eax
cmpl $0x4, %eax
ja 0x3eb6
leaq 0x2408(%rip), %rcx      # 0x626c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andl $0x7ff, %esi            # imm = 0x7FF
movw %si, 0xa766(%rip)       # 0xe5e0
jmp 0x3ed5
andl $0x0, 0xb7fb(%rip)      # 0xf67e
cmpl $0xfffe, %esi           # imm = 0xFFFE
je 0x3ecc
cmpl $0x1, %esi
jne 0x3ed5
movw $0x1, 0xb7e5(%rip)      # 0xf67e
jmp 0x3ed5
movw %si, 0xb7ce(%rip)       # 0xf670
jmp 0x3ed5
movw %si, 0xb7d1(%rip)       # 0xf67c
jmp 0x3ed5
movw %si, 0xb7c4(%rip)       # 0xf678
jmp 0x3ed5
cmpl $0x1f, %edi
jg 0x3ed5
movslq %edi, %rax
leaq 0xa70b(%rip), %rcx      # 0xe5d0
movw %si, 0x5c(%rcx,%rax,2)
jmp 0x3ed5
movw $0x1, 0xb7ab(%rip)      # 0xf680
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: examinereg
Word
examinereg(int a)
{
	word w;
	switch(a){
	case REG_PC: return ww1.pc;
	case REG_AC: return ww1.ac;
	case REG_A: return ww1.ar;
	case REG_B: return ww1.br;
	case REG_SAM:
		w = 0;
		if(ww1.ac0_carry) w |= 1;
		if(ww1.sam) w |= 0177776;
		return w;
	default:
		// Read toggle switch storage
		if(a < 32)
			return ww1.tss[a];
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x20(%rdi), %eax
cmpl $0x4, %eax
ja 0x3f36
leaq 0x2396(%rip), %rcx      # 0x6280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl 0xa6e6(%rip), %eax      # 0xe5e0
jmp 0x3f4e
xorl %ecx, %ecx
cmpw $0x0, 0xb778(%rip)      # 0xf67e
setne %cl
movl %ecx, %eax
orl $-0x2, %eax
cmpw $0x0, 0xb76a(%rip)      # 0xf680
cmovel %ecx, %eax
jmp 0x3f4e
movzwl 0xb74e(%rip), %eax      # 0xf670
jmp 0x3f4e
movzwl 0xb751(%rip), %eax      # 0xf67c
jmp 0x3f4e
movzwl 0xb744(%rip), %eax      # 0xf678
jmp 0x3f4e
cmpl $0x1f, %edi
jg 0x3f4c
movslq %edi, %rax
leaq 0xa68b(%rip), %rcx      # 0xe5d0
movzwl 0x5c(%rcx,%rax,2), %eax
jmp 0x3f4e
xorl %eax, %eax
movzwl %ax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: scope_record
void
scope_record(WWI *ww, ExUnit *eu)
{
	Scope *s = (Scope*)eu;
	if(s->fd >= 0){
		u32 cmd = 0;
		int x = ww->hdefl;
		int y = ww->vdefl;
		// Convert [-1.0,+1.0] to [0,1023]
		if(x & 02000) x++;
		if(y & 02000) y++;
		x += 02000;
		y += 02000;
		x &= 03777;
		y &= 03777;
		x >>= 1;
		y >>= 1;
		cmd = x;
		cmd |= y<<10;
		cmd |= 7<<20;
		if(write(s->fd, &cmd, 4) < 4)
			s->fd = -1;
usleep(100);
	}
	ww->interlock = 0;
	eu->active = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rsi), %edi
testl %edi, %edi
js 0x4208
movl 0x10d8(%r14), %eax
btl $0xa, %eax
adcl $0x0, %eax
movl 0x10dc(%r14), %ecx
btl $0xa, %ecx
adcl $0x0, %ecx
shrl %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x9, %ecx
andl $0xffc00, %ecx          # imm = 0xFFC00
orl %eax, %ecx
xorl $0x780200, %ecx         # imm = 0x780200
leaq -0x14(%rbp), %rsi
movl %ecx, (%rsi)
pushq $0x4
popq %rdx
callq 0x20d0
cmpq $0x3, %rax
jg 0x4200
orl $-0x1, 0x28(%rbx)
pushq $0x64
popq %rdi
callq 0x2420
andl $0x0, 0x10c4(%r14)
andl $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: ptape_record
void
ptape_record(WWI *ww, ExUnit *eu)
{
	Papertape *pt = (Papertape*)eu;
	if(pt->dly){
		pt->dly--;
		return;
	}

	int u = (ww->ios>>3) & 3;
	u8 c = ww->ior>>10 & 077;
	if(pt->p7) c |= 0100;
	write(pt->out_fd[u], &c, 1);

	if(pt->wbyw) ww->ior <<= 5;
	if(ww->ioc_counter++ == 017){
		ww->interlock = 0;
		eu->active = 0;
	}

	pt->dly = 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0x50(%rsi), %eax
testl %eax, %eax
je 0x427e
decl %eax
movl %eax, 0x50(%rbx)
jmp 0x42ed
movq %rdi, %r14
movl 0x10c8(%rdi), %eax
shrl $0x3, %eax
andl $0x3, %eax
movzwl 0x10b8(%rdi), %ecx
shrl $0xa, %ecx
movb %cl, -0x11(%rbp)
cmpl $0x0, 0x4c(%rbx)
je 0x42a6
orb $0x40, %cl
movb %cl, -0x11(%rbp)
movl 0x28(%rbx,%rax,4), %edi
leaq -0x11(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x20d0
cmpl $0x0, 0x48(%rbx)
je 0x42c5
shlw $0x5, 0x10b8(%r14)
movl 0x10c0(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x10c0(%r14)
cmpl $0xf, %eax
jne 0x42e6
andl $0x0, 0x10c4(%r14)
andl $0x0, (%rbx)
movl $0x3e8, 0x50(%rbx)      # imm = 0x3E8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: ptape_read
void
ptape_read(WWI *ww, ExUnit *eu)
{
	Papertape *pt = (Papertape*)eu;
	if(pt->dly){
		pt->dly--;
		return;
	}
	int u = (ww->ios>>3) & 3;
	if(eu->active && hasinput(pt->in_fd[u])){
		u8 c;
		read(pt->in_fd[u], &c, 1);
		if(pt->wbyw) ww->ior <<= 5;
		ww->ior |= c & 077;

		if(ww->ioc_counter++ == 017){
			ww->interlock = 0;
			eu->active = 0;
		}

		pt->dly = 1000;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x50(%rsi), %eax
testl %eax, %eax
je 0x431a
decl %eax
movl %eax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%rbx)
je 0x430f
movq %rdi, %r14
movl 0x10c8(%rdi), %r15d
shrl $0x3, %r15d
andl $0x3, %r15d
movl 0x38(%rbx,%r15,4), %edi
callq 0x3357
testl %eax, %eax
je 0x430f
movl 0x38(%rbx,%r15,4), %edi
leaq -0x19(%rbp), %r15
pushq $0x1
popq %rdx
movq %r15, %rsi
callq 0x2190
movl 0x10b8(%r14), %eax
movl %eax, %ecx
shll $0x5, %ecx
cmpl $0x0, 0x48(%rbx)
cmovel %eax, %ecx
movl 0x10c0(%r14), %eax
movzbl (%r15), %edx
andl $0x3f, %edx
orl %ecx, %edx
movw %dx, 0x10b8(%r14)
leal 0x1(%rax), %ecx
movl %ecx, 0x10c0(%r14)
cmpl $0xf, %eax
jne 0x4398
andl $0x0, 0x10c4(%r14)
andl $0x0, (%rbx)
movl $0x3e8, 0x50(%rbx)      # imm = 0x3E8
jmp 0x430f
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: readmem
void
readmem(WWI *ww, FILE *f)
{
	char buf[100], *s;
	word a, w;

	a = 0;
	while(s = fgets(buf, 100, f)){
		while(*s){
			if(*s == ';')
				break;
			else if('0' <= *s && *s <= '7'){
				w = strtol(s, &s, 8);
				if(*s == ':'){
					a = w;
					s++;
				}else if(a < 04000)
					ww->core[a++] = w;
			}else
				s++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
xorl %r15d, %r15d
pushq $0x64
popq %r12
leaq -0x30(%rbp), %r13
pushq $0x8
popq %r14
leaq -0xa0(%rbp), %rdi
movl %r12d, %esi
movq %rbx, %rdx
callq 0x21a0
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x44ba
movq %rax, %rdi
movzbl (%rdi), %eax
testl %eax, %eax
je 0x4440
cmpl $0x3b, %eax
je 0x4440
andb $-0x8, %al
cmpb $0x30, %al
jne 0x44a5
movq %r13, %rsi
movl %r14d, %edx
callq 0x21e0
movq -0x30(%rbp), %rdi
cmpb $0x3a, (%rdi)
je 0x44ae
cmpw $0x7ff, %r15w           # imm = 0x7FF
ja 0x445e
movzwl %r15w, %ecx
leal 0x1(%r15), %edx
movq -0x38(%rbp), %rsi
movw %ax, 0x9c(%rsi,%rcx,2)
movl %edx, %r15d
jmp 0x445e
incq %rdi
movq %rdi, -0x30(%rbp)
jmp 0x445e
incq %rdi
movq %rdi, -0x30(%rbp)
movl %eax, %r15d
jmp 0x445e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: printmem
void
printmem(WWI *ww)
{
	word a;
	for(a = 0; a < 04000; a++)
		if(ww->core[a])
			printf("%04o/%06o\n", a, ww->core[a]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1ebe(%rip), %r14      # 0x6432
xorl %r15d, %r15d
cmpq $0x800, %r15            # imm = 0x800
je 0x459f
movzwl 0x9c(%rbx,%r15,2), %edx
testl %edx, %edx
je 0x459a
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x2100
incq %r15
jmp 0x4577
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: handlemsg
void
handlemsg(WWI *ww, Msg msg)
{
	switch(msg.cmd){
	case CMD_NONE:
		break;
	case CMD_SET_PC:
		ww->pc_sw = msg.arg & ADDRMASK;
		ww->pc = ww->pc_sw;
		break;
	case CMD_STEP:
		ww->order_by_order = 1;
		ww->run = 1;
		break;
	case CMD_RUN:
		ww->order_by_order = 0;
		ww->run = 1;
		break;
	case CMD_STOP:
		ww->run = 0;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rsi), %eax
cmpl $0x3, %eax
ja 0x45f9
leaq 0x1d57(%rip), %rcx      # 0x6314
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrq $0x20, %rsi
andl $0x7ff, %esi            # imm = 0x7FF
movw %si, (%rdi)
movw %si, 0x10(%rdi)
jmp 0x45f9
movabsq $0x100000000, %rax      # imm = 0x100000000
jmp 0x45f5
andl $0x0, 0x8(%rdi)
jmp 0x45f9
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: handleio
void
handleio(WWI *ww)
{
	if(ww->active_unit && ww->active_unit->active){
		if(ww->ioc_out)
			ww->active_unit->record(ww, ww->active_unit);
		else
			ww->active_unit->read(ww, ww->active_unit);
	}

	if(ww->scope->fd >= 0 && hasinput(ww->scope->fd)){
		u32 input;
		if(readn(ww->scope->fd, &input, 4) < 0){
			ww->scope->fd = -1;
			return;
		}
		if(input & 0x80000000){
			// light pen/gun
			ww->scope->gunx = input & 01777;
			ww->scope->guny = (input>>10) & 01777;
			ww->scope->gun = (input>>20) & 1;
		}else{
			int id = input>>24;
			// we'll use FF register 2 for the input bits
			if(id == 0){
				ww->ffs[2] &= ~0140000;	// need upper 2 bits
				if(input & 0200) ww->ffs[2] |= 0100000;	// up
				if(input & 0100) ww->ffs[2] |= 0040000;	// down
			}else{
				ww->ffs[2] &= ~0030000;	// need next 2 bits
				if(input & 0200) ww->ffs[2] |= 0020000;	// up
				if(input & 0100) ww->ffs[2] |= 0010000;	// down
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10d0(%rdi), %rsi
testq %rsi, %rsi
je 0x4628
cmpl $0x0, (%rsi)
je 0x4628
xorl %eax, %eax
cmpl $0x0, 0x10bc(%rbx)
sete %al
movq %rbx, %rdi
callq *0x18(%rsi,%rax,8)
movq 0x10e0(%rbx), %rax
movl 0x28(%rax), %edi
testl %edi, %edi
js 0x46ed
callq 0x3357
testl %eax, %eax
je 0x46ed
movq 0x10e0(%rbx), %rax
movl 0x28(%rax), %edi
leaq -0xc(%rbp), %rsi
pushq $0x4
popq %rdx
callq 0x340a
testl %eax, %eax
js 0x4693
movl -0xc(%rbp), %eax
testl %eax, %eax
js 0x46a0
movzwl 0x20(%rbx), %ecx
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0x46c8
andl $0x3fff, %ecx           # imm = 0x3FFF
movl %eax, %edx
andl $-0x80, %edx
shll $0x8, %edx
orl %ecx, %edx
movw %dx, 0x20(%rbx)
testb $0x40, %al
je 0x46ed
orl $0x4000, %edx           # imm = 0x4000
jmp 0x46e9
movq 0x10e0(%rbx), %rax
orl $-0x1, 0x28(%rax)
jmp 0x46ed
movl $0x3ff, %ecx            # imm = 0x3FF
movl %eax, %edx
andl %ecx, %edx
movq 0x10e0(%rbx), %rsi
movl %edx, 0x30(%rsi)
movl %eax, %edx
shrl $0xa, %edx
andl %ecx, %edx
movl %edx, 0x34(%rsi)
shrl $0x14, %eax
andl $0x1, %eax
movl %eax, 0x2c(%rsi)
jmp 0x46ed
andl $0xffffcfff, %ecx       # imm = 0xFFFFCFFF
movl %eax, %edx
shll $0x6, %edx
andl $0x2000, %edx           # imm = 0x2000
orl %ecx, %edx
movw %dx, 0x20(%rbx)
testb $0x40, %al
je 0x46ed
orl $0x1000, %edx           # imm = 0x1000
movw %dx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: consthread
void*
consthread(void *arg)
{
	WWI *ww = (WWI*)arg;
	FILE *f;
	f = fdopen(ww->console_fd, "w");

	for(;;){
		fprintf(f, "\033[1J\033[H");	// clear
		fprintf(f, "CS/%02o\n", ww->cs);
		fprintf(f, "PC/%04o\n", ww->pc);
		fprintf(f, "PR/%06o\n", ww->par);
		fprintf(f, "AC/%06o\n", ww->ac);
		fprintf(f, "AR/%06o\n", ww->ar);
		fprintf(f, "BR/%06o\n", ww->br);
		usleep(50000);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10f0(%rdi), %edi
leaq 0xda8(%rip), %rsi       # 0x643d
callq 0x2260
movq %rax, %r14
leaq 0xdbe(%rip), %r15       # 0x6462
leaq 0xdc0(%rip), %r12       # 0x646b
leaq 0xdc2(%rip), %r13       # 0x6474
leaq 0xd86(%rip), %rdi       # 0x643f
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x2380
movzwl 0x14(%rbx), %edx
movq %r14, %rdi
leaq 0xd72(%rip), %rsi       # 0x6447
xorl %eax, %eax
callq 0x21d0
movzwl 0x10(%rbx), %edx
movq %r14, %rdi
leaq 0xd66(%rip), %rsi       # 0x6450
xorl %eax, %eax
callq 0x21d0
movzwl 0x109c(%rbx), %edx
movq %r14, %rdi
leaq 0xd57(%rip), %rsi       # 0x6459
xorl %eax, %eax
callq 0x21d0
movzwl 0x10a8(%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21d0
movzwl 0x10a0(%rbx), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21d0
movzwl 0x10ac(%rbx), %edx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x21d0
movl $0xc350, %edi           # imm = 0xC350
callq 0x2420
jmp 0x56b2
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: cpu_start
void
cpu_start(Addr a)
{
	Msg msg;
	msg.cmd = CMD_SET_PC;
	msg.arg = a;
	chansend(cmdchan, &msg);
	msg.cmd = CMD_RUN;
	chansend(cmdchan, &msg);
	chansend(cmdchan, &msg_none);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movl $0x1, (%rbx)
movl %edi, 0x4(%rbx)
movq 0x9fca(%rip), %rdi      # 0xf738
movq %rbx, %rsi
callq 0x3b39
movl $0x3, (%rbx)
movq 0x9fb5(%rip), %rdi      # 0xf738
movq %rbx, %rsi
callq 0x3b39
movq 0x9fa6(%rip), %rdi      # 0xf738
leaq 0x9fa7(%rip), %rsi      # 0xf740
callq 0x3b39
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: cpu_setpc
void
cpu_setpc(Addr pc)
{
	Msg msg;
	msg.cmd = CMD_SET_PC;
	msg.arg = pc;
	chansend(cmdchan, &msg);
	chansend(cmdchan, &msg_none);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rsi
movl $0x1, (%rsi)
movl %edi, 0x4(%rsi)
movq 0x9f77(%rip), %rdi      # 0xf738
callq 0x3b39
movq 0x9f6b(%rip), %rdi      # 0xf738
leaq 0x9f6c(%rip), %rsi      # 0xf740
callq 0x3b39
addq $0x10, %rsp
popq %rbp
retq