LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/parsing.c
// Function: build_wrong_type_message
static char *build_wrong_type_message(wrong_type_t *wrong_type, unsigned char message_type) {
	static const char* message_types[] = {
		"Invalid assignment: expected ",
		"Invalid return type: expected ",
		"Ternary condition operands must have the same type: left is "
	};
	char *message = NULL;
	char *tmp = NULL;
	char *seq = NULL;

	message = strconcat((char*)message_types[message_type] , wrong_type->expected_type->name);
	seq = generate_char_sequence('*', wrong_type->expected_type->is_pointer);
	tmp = strconcat(message, seq);
	free(seq);
	free(message);

	message = strconcat(tmp, (char*)(message_type == WRONG_TYPE_TERNARY ? ", right is " : ", actual "));
	free(tmp);
	tmp = strconcat(message, wrong_type->actual_type->name);
	free(message);
	seq = generate_char_sequence('*', wrong_type->actual_type->is_pointer);
	message = strconcat(tmp, seq);
	free(seq);
	free(tmp);

	return message;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, %ecx
leaq 0x9979(%rip), %rax      # 0x184a0
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0xa9b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x8(%rax), %esi
movl $0x2a, %edi
callq 0xb270
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa9b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
movzbl -0x9(%rbp), %ecx
leaq 0x60c8(%rip), %rsi      # 0x14c51
leaq 0x60b5(%rip), %rax      # 0x14c45
cmpl $0x2, %ecx
cmoveq %rax, %rsi
callq 0xa9b0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0xa9b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x8(%rax), %esi
movl $0x2a, %edi
callq 0xb270
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa9b0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/parsing.c
// Function: free_wrong_type_list
static void free_wrong_type_list(arraylist_t *list) {
	wrong_type_t *wrong_type = NULL;

	for(size_t i = 0 ; i < list->size ; i++) {
		wrong_type = arraylist_get(list, i);
		free(wrong_type->expected_type->name);
		free(wrong_type->expected_type);
		free(wrong_type->actual_type->name);
		free(wrong_type->actual_type);
	}

	arraylist_free(list, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xeca1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8890
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xec3c
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8a00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/rules/comments_header.c
// Function: check_comments_header
unsigned int check_comments_header(arraylist_t *file, char *filename) {
	int index = 0;
	int length;
	char *line;

	for(size_t i = 0 ; i < file->size ; i++){
		line = arraylist_get(file, i);
		length = strlen(line);
		index = 0;
		while(is_whitespace(line[index]) && index < length) {
			index++;
		}
		if(index < length - 1) {
			if(line[index] == '/' && line[index + 1] == '*') {
				return 0;
			} else {
				print_warning(filename, i + 1, NULL, "File doesn't start with a comments header");
				return 1;
			}
		}
	}
	print_warning(filename, file->size, NULL, "File doesn't start with a comments header");
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xedca
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8890
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2090
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xed3f
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xed48
jmp 0xed53
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xed15
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xedb7
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xed90
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0xed90
movl $0x0, -0x4(%rbp)
jmp 0xedef
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
addq $0x1, %rax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x5eb2(%rip), %rcx      # 0x14c5b
callq 0x6850
movl $0x1, -0x4(%rbp)
jmp 0xedef
jmp 0xedb9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xecdf
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x5e78(%rip), %rcx      # 0x14c5b
callq 0x6850
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_functions.c
// Function: function_init
function_t *function_init(char *name, unsigned char is_prototype, char *type, unsigned char type_is_pointer, arraylist_t *params, int line_index) {
	function_t *function = malloc(sizeof(function_t));

	if(function != NULL) {
		function->name                   = name;
		function->is_prototype           = is_prototype;
		function->return_type.name       = type;
		function->return_type.is_pointer = type_is_pointer;
		function->params                 = params;
		function->line                   = line_index;
		function->negate_operator        = 0;
	}

	return function;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x30, %edi
callq 0x2110
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xee84
movq -0x8(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movb -0x9(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x19(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_functions.c
// Function: function_is_prototype
static unsigned char function_is_prototype(char *line) {
	size_t length = strlen(line);
	int index = length - 1;

	while(is_whitespace(line[index]) && index >= 0) { index--; }; //Skip whitespaces

	switch(line[index]) {
		case ';': return 1;
		case '{': return 0;
		default: return -1; //Syntax error
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa7d0
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0xf22c
cmpl $0x0, -0x1c(%rbp)
setge %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xf235
jmp 0xf240
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf204
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
subl $0x3b, %eax
je 0xf260
jmp 0xf256
movl -0x24(%rbp), %eax
subl $0x7b, %eax
je 0xf266
jmp 0xf26c
movb $0x1, -0x1(%rbp)
jmp 0xf270
movb $0x0, -0x1(%rbp)
jmp 0xf270
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_expressions.c
// Function: check_return_type
static void check_return_type(type_t type, scope_t *scope, messages_t *messages) {
	scope_t *function_scope = get_function_scope(scope);
	scope_t *root_scope = function_scope->parent;
	function_t *function = NULL;

	if(root_scope == NULL) return;

	for(size_t i = 0 ; i < root_scope->functions->size ; i++) {
		function = arraylist_get(root_scope->functions, i);
		if(function->line == function_scope->from_line) {
			if(!type_equals(&(function->return_type), &type))
				add_wrong_return_message(messages, &(function->return_type), &type);
			break;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x82d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x10f51
jmp 0x10fcc
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x10fcc
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x8890
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x10fbc
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x8080
cmpb $0x0, %al
jne 0x10fba
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
leaq -0x10(%rbp), %rdx
callq 0x11680
jmp 0x10fcc
jmp 0x10fbe
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x10f59
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_expressions.c
// Function: parse_number_literal
static void parse_number_literal(char *line, int length, int index, type_t *type) {
	char c;

	//Get all digits
	while(is_digit(c = line[index]) && index < length) {
		index++;
	}

	if(c == '.') { //Float or double
		parse_float_literal(line, length, index, type);
	} else if(is_type_identifier(c)) {
		parse_integer_literal(line, length, index, type);
	} else {
		type->name = strduplicate("int");
		type->is_literal = 1;
		type->is_pointer = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl %al, %edi
callq 0xae10
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
je 0x11295
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x1129e
jmp 0x112a9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11266
movsbl -0x19(%rbp), %eax
cmpl $0x2e, %eax
jne 0x112c7
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x117c0
jmp 0x11311
movsbl -0x19(%rbp), %edi
callq 0x11920
cmpb $0x0, %al
je 0x112e9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x119b0
jmp 0x1130f
leaq 0x3615(%rip), %rdi      # 0x14905
callq 0xa550
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x8(%rax)
jmp 0x11311
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_expressions.c
// Function: find_semi_colon
static int find_semi_colon(char *line, int index, int length) {
	int sc_index = strindexof(line + index,  ';') + index;

	if(sc_index != -1 && check_quotes(line, line + sc_index, length)) {
		return find_semi_colon(line, sc_index + 1, length);
	}

	return sc_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movl $0x3b, %esi
callq 0xa8d0
addl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x117a9
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movl -0x18(%rbp), %edx
callq 0xae60
movzbl %al, %eax
cmpl $0x0, %eax
je 0x117a9
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
addl $0x1, %esi
movl -0x18(%rbp), %edx
callq 0x11740
movl %eax, -0x4(%rbp)
jmp 0x117af
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/parsing_expressions.c
// Function: parse_float_literal
static void parse_float_literal(char *line, int length, int index, type_t *type) {
	char *type_identifier = NULL;
	char c = line[++index];
	if(is_digit(c)) {
		while(is_digit(c = line[index]) && index < length) {
			index++;
		}

		if(index >= length || c == ';' || is_whitespace(c)) {
			type_identifier = "double";
		} else if(is_type_identifier(c)) {
			switch(c) {
				case 'f':
				case 'F':
				type_identifier = "float";
				break;
				case 'd':
				case 'D':
				type_identifier = "double";
				break;
				case 'l':
				case 'L':
				type_identifier = "long double";
				break;
			}

		}

		if(type_identifier != NULL) {
			free(type->name);
			type->name = strduplicate(type_identifier);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0xae10
cmpb $0x0, %al
je 0x11917
jmp 0x11807
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl %al, %edi
callq 0xae10
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0x11836
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x1183f
jmp 0x1184a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11807
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1186c
movsbl -0x21(%rbp), %eax
cmpl $0x3b, %eax
je 0x1186c
movsbl -0x21(%rbp), %edi
callq 0xa7d0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x11879
leaq 0x30d3(%rip), %rax      # 0x14946
movq %rax, -0x20(%rbp)
jmp 0x118ef
movsbl -0x21(%rbp), %edi
callq 0x11920
cmpb $0x0, %al
je 0x118ed
movsbl -0x21(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x44, %eax
je 0x118d3
jmp 0x11894
movl -0x28(%rbp), %eax
subl $0x46, %eax
je 0x118c6
jmp 0x1189e
movl -0x28(%rbp), %eax
subl $0x4c, %eax
je 0x118e0
jmp 0x118a8
movl -0x28(%rbp), %eax
subl $0x64, %eax
je 0x118d3
jmp 0x118b2
movl -0x28(%rbp), %eax
subl $0x66, %eax
je 0x118c6
jmp 0x118bc
movl -0x28(%rbp), %eax
subl $0x6c, %eax
je 0x118e0
jmp 0x118eb
leaq 0x348e(%rip), %rax      # 0x14d5b
movq %rax, -0x20(%rbp)
jmp 0x118eb
leaq 0x306c(%rip), %rax      # 0x14946
movq %rax, -0x20(%rbp)
jmp 0x118eb
leaq 0x305a(%rip), %rax      # 0x14941
movq %rax, -0x20(%rbp)
jmp 0x118ed
jmp 0x118ef
cmpq $0x0, -0x20(%rbp)
je 0x11915
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0xa550
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x11917
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/System-Glitch[P]ESGILinter-C/src/main.c
// Function: get_lines_list
static arraylist_t *get_lines_list(arraylist_t *buffer) {
	arraylist_t *lines = arraylist_init(buffer->size);

	for(size_t i = 0 ; i < buffer->size ; i++) {
		arraylist_add(lines, strduplicate(((line_t*)arraylist_get(buffer, i))->line));
	}

	return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edi
callq 0x8580
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1246c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8890
movq (%rax), %rdi
callq 0xa550
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x8730
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12427
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/hex.h
// Function: hexString8ToUint8
static inline uint8_t hexString8ToUint8(const uint8_t hexString8) {
    if ('0' <= hexString8 && hexString8 <= '9') {
        return hexString8 - '0';
    }
    if ('a' <= hexString8 && hexString8 <= 'f') {
        return hexString8 - 'a' + 0xa;
    }
    if ('A' <= hexString8 && hexString8 <= 'F') {
        return hexString8 - 'A' + 0xa;
    }
    fprintf(stderr, "hexString8ToUint8: unexpected hex string %u (%c)\n", hexString8, hexString8);
    return 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x16eb0
movzbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0x16eb0
movzbl -0x2(%rbp), %eax
subl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0x16f1e
movzbl -0x2(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x16ed5
movzbl -0x2(%rbp), %eax
cmpl $0x66, %eax
jg 0x16ed5
movzbl -0x2(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x1(%rbp)
jmp 0x16f1e
movzbl -0x2(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x16efa
movzbl -0x2(%rbp), %eax
cmpl $0x46, %eax
jg 0x16efa
movzbl -0x2(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x1(%rbp)
jmp 0x16f1e
movq 0xa0f7(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
movzbl -0x2(%rbp), %edx
movzbl -0x2(%rbp), %ecx
leaq 0x881a(%rip), %rsi      # 0x1f72d
movb $0x0, %al
callq 0x2070
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: punchLeader
void punchLeader( WORD32 count )
{
  WORD32  ix;

  /* If value is zero, set to the default of 2 feet of leader.                */
  count = ( count == 0 ) ? 240 : count;

  if( objectfile != NULL )
  {
    for( ix = 0; ix < count; ix++ )
    {
      fputc( 0200, objectfile );
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x375e
movl $0xf0, %eax
movq %rax, -0x18(%rbp)
jmp 0x3766
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, 0x1571a(%rip)     # 0x18e90
je 0x37ab
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x37a9
movq 0x156ff(%rip), %rsi     # 0x18e90
movl $0x80, %edi
callq 0x20d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3780
jmp 0x37ab
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: endOfBinary
void endOfBinary()
{
  /* Points to end of page for () operands.                                   */
  punchLiteralPool( &cp, clc - 1 );
  /* Points to end of page zero for [] operands.                              */
  punchLiteralPool( &pz, field );
  if( error_in_line )
  listLine();             /* List line if not done yet.                       */
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x148d5(%rip), %rsi     # 0x19050
subq $0x1, %rsi
leaq 0x158fa(%rip), %rdi     # 0x1a080
callq 0x4ae0
movq 0x148c6(%rip), %rsi     # 0x19058
leaq 0x15cef(%rip), %rdi     # 0x1a488
callq 0x4ae0
cmpb $0x0, 0x1650b(%rip)     # 0x1acb0
je 0x47ac
callq 0x86b0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: punchLiteralPool
void punchLiteralPool( LPOOL_T *p, WORD32 lpool_page )
{
  WORD32  loc;
  WORD32  pageno;
  WORD32  tmplc;

  pageno  = GET_PAGE (lpool_page);
  lpool_page &= 07600;

  if(( lpool_page == 0 ) && ( p != &pz ))
  {
    return;                     /* Don't punch page 0 pool if not asked.     */
  }

  if( lit_loc[pageno] < lit_base[pageno] )
  {
    if( !rim_mode )
    {
      /* Put out origin if not in rim mode.                                   */
		punchOrigin( lit_loc[pageno] | lpool_page );
	 }
      /* Put the literals in the object file.                                 */
    for( loc = lit_loc[pageno]; loc < lit_base[pageno]; loc++ )
    {
      tmplc = loc + lpool_page;
      printLine( line, (field | tmplc), p->pool[loc], LOC_VAL );
      punchLocObject( tmplc, p->pool[loc] );
    }
    p->error = FALSE;
    lit_base[pageno] = lit_loc[pageno];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
sarq $0x7, %rax
andq $0xff, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq $0xf80, %rax            # imm = 0xF80
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4b29
leaq 0x1596a(%rip), %rax     # 0x1a488
cmpq %rax, -0x8(%rbp)
je 0x4b29
jmp 0x4c18
movq -0x20(%rbp), %rcx
leaq 0x14d3c(%rip), %rax     # 0x19870
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rdx
leaq 0x1452d(%rip), %rcx     # 0x19070
cmpq (%rcx,%rdx,8), %rax
jge 0x4c18
cmpb $0x0, 0xa1e0(%rip)      # 0xed34
jne 0x4b6e
movq -0x20(%rbp), %rcx
leaq 0x14d0f(%rip), %rax     # 0x19870
movq (%rax,%rcx,8), %rdi
orq -0x10(%rbp), %rdi
callq 0x4c20
movq -0x20(%rbp), %rcx
leaq 0x14cf7(%rip), %rax     # 0x19870
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
leaq 0x144e0(%rip), %rcx     # 0x19070
cmpq (%rcx,%rdx,8), %rax
jge 0x4bef
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x144af(%rip), %rsi     # 0x19058
orq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
leaq 0x15cff(%rip), %rdi     # 0x1a8c0
movl $0x3, %ecx
callq 0x4c60
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rsi
callq 0x8a10
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4b81
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
leaq 0x14c6b(%rip), %rax     # 0x19870
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rcx
leaq 0x1445c(%rip), %rax     # 0x19070
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: lexemeToName
char *lexemeToName( char *name, WORD32 from, WORD32 term )
{
  WORD32  to;

  to = 0;

  while( from < term && to < ( SYMLEN - 1 ))
  {
    name[to++] = to_upper( line[from++] );
  }

  while( to < SYMLEN )
  {
    name[to++] = '\0';
  }
  return( name );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x21(%rbp)
jge 0x50c6
cmpq $0x6, -0x20(%rbp)
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x50cf
jmp 0x5108
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
leaq 0x157db(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %edi
callq 0x2080
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x50ac
jmp 0x510a
cmpq $0x7, -0x20(%rbp)
jge 0x512a
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb $0x0, (%rax,%rcx)
jmp 0x510a
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: errorSymbol
void errorSymbol( EMSG_T *mesg, char *name, WORD32 col )
{
  char   linecol[40]; // [12] to [40] donorth 2020-03-18
  char  *s;

  if( pass == 2 )
  {
    s = ( name == NULL ) ? "" : name ;
    errors++;
    sprintf( linecol, "(%d:%ld)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s \"%s\" at Loc = %5.5o\n",
	     filename, linecol, mesg->file, s, (unsigned)clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x2, 0xbc74(%rip)      # 0x10dd0
jne 0x51fb
cmpq $0x0, -0x10(%rbp)
jne 0x5176
leaq 0x56ba(%rip), %rax      # 0xa82a
movq %rax, -0x50(%rbp)
jmp 0x517e
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0xbc3c(%rip), %eax      # 0x10dc8
addl $0x1, %eax
movl %eax, 0xbc33(%rip)      # 0x10dc8
leaq -0x40(%rbp), %rdi
movl 0x156fd(%rip), %edx     # 0x1a89c
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
leaq 0x57db(%rip), %rsi      # 0xa989
movb $0x0, %al
callq 0x2170
movq 0xbc04(%rip), %rdi      # 0x10dc0
leaq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x48(%rbp), %r9
movq 0x13e7d(%rip), %rax     # 0x19050
leaq 0x57b8(%rip), %rsi      # 0xa992
leaq 0x13def(%rip), %rdx     # 0x18fd0
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x8ff0
movb $0x1, 0x15aae(%rip)     # 0x1acb0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: evalSymbol
SYM_T *evalSymbol()
{
  char   name[SYMLEN];
  SYM_T *sym;

  sym = lookup( lexemeToName( name, lexstart, lexterm ));

  sym->xref_count++;            /* Count the number of references to symbol.  */

  if( xref && pass == 2 )
  {
    /* Put the line number in the concordance table.                          */
    xreftab[sym->xref_index + sym->xref_count] = lineno;
  }

  return( sym );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x7(%rbp), %rdi
movq 0x15735(%rip), %rsi     # 0x1aca8
movq 0x1573e(%rip), %rdx     # 0x1acb8
callq 0x5090
movq %rax, %rdi
callq 0x4ee0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movzbl 0x9794(%rip), %eax      # 0xed36
cmpl $0x0, %eax
je 0x55d3
cmpq $0x2, 0xb821(%rip)      # 0x10dd0
jne 0x55d3
movslq 0x152e4(%rip), %rdx     # 0x1a89c
movq 0x13971(%rip), %rax     # 0x18f30
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rsi
addq 0x20(%rsi), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: testZeroPool
BOOL testZeroPool( WORD32 value )
{
  WORD32 ix;
  WORD32 pageno;

  pageno = GET_PAGE( field );
  for ( ix = lit_loc[pageno]; ix < lit_base[pageno]; ix++ )
  {
    if( pz.pool[ix] == value ) return TRUE;
  }
  return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x12109(%rip), %rax     # 0x19058
sarq $0x7, %rax
andq $0xff, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x12908(%rip), %rax     # 0x19870
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
leaq 0x120f1(%rip), %rcx     # 0x19070
cmpq (%rcx,%rdx,8), %rax
jge 0x6fb1
movq -0x18(%rbp), %rcx
leaq 0x134f8(%rip), %rax     # 0x1a488
movq 0x8(%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x6fa1
movb $0x1, -0x1(%rbp)
jmp 0x6fb5
jmp 0x6fa3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6f70
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: insertLiteral
WORD32 insertLiteral( LPOOL_T *pool, WORD32 pool_page, WORD32 value )
{
  WORD32  ix;
  WORD32  pageno;
  LPOOL_T *p;

  p = pool;
  pageno = GET_PAGE (pool_page);

  /* If page zero is the current page, make sure that literals are inserted   */
  /* in the page zero literal table.                                          */
  if(( pool_page & 07600 ) == 0 )
  {
     p = &pz;
  }

  /* Search the literal pool for any occurence of the needed value.           */
  ix = lit_base[pageno] - 1;
  while( ix >= lit_loc[pageno] && p->pool[ix] != value )
  {
    ix--;
  }

  /* Check if value found in literal pool. If not, then insert value.         */
  if( ix < lit_loc[pageno] )
  {
    lit_loc[pageno]--;
    p->pool[lit_loc[pageno]] = value;
    ix = lit_loc[pageno];
  }
  return( ix );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
sarq $0x7, %rax
andq $0xff, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
andq $0xf80, %rax            # imm = 0xF80
cmpq $0x0, %rax
jne 0x7005
leaq 0x13487(%rip), %rax     # 0x1a488
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
leaq 0x12060(%rip), %rax     # 0x19070
movq (%rax,%rcx,8), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rsi
xorl %eax, %eax
leaq 0x12843(%rip), %rdx     # 0x19870
cmpq (%rdx,%rsi,8), %rcx
movb %al, -0x31(%rbp)
jl 0x704d
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x7056
jmp 0x7064
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x701c
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdx
leaq 0x127fd(%rip), %rcx     # 0x19870
cmpq (%rcx,%rdx,8), %rax
jge 0x70c6
movq -0x28(%rbp), %rcx
leaq 0x127ec(%rip), %rax     # 0x19870
movq (%rax,%rcx,8), %rdx
addq $-0x1, %rdx
leaq 0x127dd(%rip), %rax     # 0x19870
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rsi
leaq 0x127c6(%rip), %rcx     # 0x19870
movq (%rcx,%rsi,8), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x28(%rbp), %rcx
leaq 0x127b2(%rip), %rax     # 0x19870
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: errorMessage
void errorMessage( EMSG_T *mesg, WORD32 col )
{
  char   linecol[40]; // [12] to [40] donorth 2020-03-18

  if( pass == 2 )
  {
    errors++;
    sprintf( linecol, "(%d:%ld)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s at Loc = %5.5o\n",
	     filename, linecol, mesg->file, (unsigned)clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x2, 0x9768(%rip)      # 0x10dd0
jne 0x76db
movl 0x9758(%rip), %eax      # 0x10dc8
addl $0x1, %eax
movl %eax, 0x974f(%rip)      # 0x10dc8
leaq -0x40(%rbp), %rdi
movl 0x13219(%rip), %edx     # 0x1a89c
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
leaq 0x32f7(%rip), %rsi      # 0xa989
movb $0x0, %al
callq 0x2170
movq 0x9720(%rip), %rdi      # 0x10dc0
leaq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movq 0x1199d(%rip), %rax     # 0x19050
movl %eax, %r9d
leaq 0x32fe(%rip), %rsi      # 0xa9bb
leaq 0x1190c(%rip), %rdx     # 0x18fd0
movb $0x0, %al
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8ff0
movb $0x1, 0x135ce(%rip)     # 0x1acb0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: moveToEndOfLine
void moveToEndOfLine()
{
  while( !is_end( line[cc] )) cc++;
  lexstart = cc;
  lexterm = cc;
  lexstartprev = lexstart;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x76f6
movq 0x135d3(%rip), %rcx     # 0x1acd0
leaq 0x131bc(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
je 0x772d
movq 0x135b7(%rip), %rcx     # 0x1acd0
leaq 0x131a0(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7738
jmp 0x774c
movq 0x13591(%rip), %rax     # 0x1acd0
addq $0x1, %rax
movq %rax, 0x13586(%rip)     # 0x1acd0
jmp 0x76f6
movq 0x1357d(%rip), %rax     # 0x1acd0
movq %rax, 0x1354e(%rip)     # 0x1aca8
movq 0x1356f(%rip), %rax     # 0x1acd0
movq %rax, 0x13550(%rip)     # 0x1acb8
movq 0x13539(%rip), %rax     # 0x1aca8
movq %rax, 0x13552(%rip)     # 0x1acc8
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: getDublExprs
WORD32 getDublExprs()
{
  WORD32 dublvalue;

  dublvalue = getDublExpr();

  while( TRUE )
  {
    if( is_done( line[lexstart] ))
    {
      return( dublvalue );
    }
    else
    {
      errorMessage( &illegal_expression, lexstart - 1 );
      return( 0 );
    }
  } /* end while                                                              */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x79a0
movq %rax, -0x10(%rbp)
movq 0x13390(%rip), %rcx     # 0x1aca8
leaq 0x12fa1(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x796d
movq 0x13379(%rip), %rcx     # 0x1aca8
leaq 0x12f8a(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x796d
movq 0x13362(%rip), %rcx     # 0x1aca8
leaq 0x12f73(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x796d
movq 0x1334b(%rip), %rcx     # 0x1aca8
leaq 0x12f5c(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
jne 0x7977
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7996
movq 0x1332a(%rip), %rsi     # 0x1aca8
subq $0x1, %rsi
leaq 0x7017(%rip), %rdi      # 0xe9a0
callq 0x7650
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: evalDubl
WORD32 evalDubl( WORD32 initial_value )
{
  WORD32  digit;
  WORD32  from;
  WORD32  dublvalue;
  WORD32  olddublvalue;

  overflow = FALSE;
  delimiter = line[lexterm];
  from = lexstart;
  dublvalue = initial_value;

  while( from < lexterm )
  {
    if( is_digit( line[from] ))
    {
      olddublvalue = dublvalue;
      digit = (WORD32)( line[from++] - '0' );
      dublvalue = dublvalue * 10 + digit;
      if( dublvalue < olddublvalue )
      {
        overflow = TRUE;
      }
    }
    else
    {
      errorLexeme( &not_a_number, from );
      dublvalue = 0;
      from = lexterm;
    }
  }
  return( dublvalue );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, 0x134cd(%rip)     # 0x1b0e0
movq 0x1309e(%rip), %rcx     # 0x1acb8
leaq 0x12c9f(%rip), %rax     # 0x1a8c0
movb (%rax,%rcx), %al
movb %al, 0x13096(%rip)      # 0x1acc0
movq 0x13077(%rip), %rax     # 0x1aca8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x13070(%rip), %rax     # 0x1acb8
jge 0x7ce9
callq 0x2190
movq (%rax), %rax
movq -0x18(%rbp), %rdx
leaq 0x12c5f(%rip), %rcx     # 0x1a8c0
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x7cc1
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
leaq 0x12c2c(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
cltq
movq %rax, -0x10(%rbp)
imulq $0xa, -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x7cbf
movb $0x1, 0x13421(%rip)     # 0x1b0e0
jmp 0x7ce4
movq -0x18(%rbp), %rsi
leaq 0x6cf4(%rip), %rdi      # 0xe9c0
callq 0x5260
movq $0x0, -0x20(%rbp)
movq 0x12fd8(%rip), %rax     # 0x1acb8
movq %rax, -0x18(%rbp)
jmp 0x7c3d
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: getFltgExprs
FLTG_T *getFltgExprs()
{
  FLTG_T *fltg;

  fltg = getFltgExpr();

  while( TRUE )
  {
    if( is_done( line[lexstart] ))
    {
      return( fltg );
    }
    else
    {
      errorMessage( &illegal_expression, lexstart - 1 );
      return( 0 );
    }
  } /* end while                                                              */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x7f50
movq %rax, -0x10(%rbp)
movq 0x12de0(%rip), %rcx     # 0x1aca8
leaq 0x129f1(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x7f1d
movq 0x12dc9(%rip), %rcx     # 0x1aca8
leaq 0x129da(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7f1d
movq 0x12db2(%rip), %rcx     # 0x1aca8
leaq 0x129c3(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x7f1d
movq 0x12d9b(%rip), %rcx     # 0x1aca8
leaq 0x129ac(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
jne 0x7f27
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7f46
movq 0x12d7a(%rip), %rsi     # 0x1aca8
subq $0x1, %rsi
leaq 0x6a67(%rip), %rdi      # 0xe9a0
callq 0x7650
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: testForLiteralCollision
BOOL testForLiteralCollision( WORD32 loc )
{
  WORD32  pagelc;
  WORD32  pageno;
  BOOL    result = FALSE;

  pageno  = GET_PAGE (loc);
  pagelc  = loc & 00177;

  if( pageno == 0 )
  {
    if( pagelc >= lit_loc[pageno] && !pz.error )
    {
      errorMessage( &pz_literal_overflow, -1 );
      pz.error = TRUE;
      result = TRUE;
    }
  }
  else
  {
    if( pagelc >= lit_loc[pageno] && !cp.error )
    {
      errorMessage( &literal_overflow, -1 );
      cp.error = TRUE;
      result = TRUE;
    }
  }
  return( result );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rax
sarq $0x7, %rax
andq $0xff, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
andq $0x7f, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8658
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
leaq 0x1124c(%rip), %rcx     # 0x19870
cmpq (%rcx,%rdx,8), %rax
jl 0x8656
cmpq $0x0, 0x11e56(%rip)     # 0x1a488
jne 0x8656
leaq 0x6425(%rip), %rdi      # 0xea60
movq $-0x1, %rsi
callq 0x7650
movq $0x1, 0x11e36(%rip) # 0x1a488
movb $0x1, -0x19(%rbp)
jmp 0x869b
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
leaq 0x11209(%rip), %rcx     # 0x19870
cmpq (%rcx,%rdx,8), %rax
jl 0x8699
cmpq $0x0, 0x11a0b(%rip)     # 0x1a080
jne 0x8699
leaq 0x63d2(%rip), %rdi      # 0xea50
movq $-0x1, %rsi
callq 0x7650
movq $0x1, 0x119eb(%rip) # 0x1a080
movb $0x1, -0x19(%rbp)
jmp 0x869b
movb -0x19(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: topOfForm
void topOfForm( char *title, char *sub_title )
{
  char temp[30]; // [10] to [30] donorth 2020-03-18

  if (!listfile) return;
  list_pageno++;
  strcpy( temp, s_page );
  sprintf( temp, "%s %d", s_page, list_pageno );

  /* Output a top of form if not the first page of the listing.               */
  if( list_pageno > 1 )
  {
    fprintf( listfile, "\f" );
  }
  fprintf( listfile, "\n      %-63s %10s\n", title, temp );

  /* Reset the current page line counter.                                     */
  page_lineno = 1;
  if( sub_title != NULL )
  {
    fprintf( listfile, "%80s\n", sub_title );
    page_lineno++;
  }
  else
  {
    fprintf( listfile, "\n" );
    page_lineno++;
  }
  fprintf( listfile, "\n" );
  page_lineno++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x10828(%rip)     # 0x18f20
jne 0x86ff
jmp 0x87fb
movl 0x1219b(%rip), %eax     # 0x1a8a0
addl $0x1, %eax
movl %eax, 0x12192(%rip)     # 0x1a8a0
leaq -0x30(%rbp), %rdi
leaq 0x6220(%rip), %rsi      # 0xe939
callq 0x2070
leaq -0x30(%rbp), %rdi
movl 0x12178(%rip), %ecx     # 0x1a8a0
leaq 0x2239(%rip), %rsi      # 0xa968
leaq 0x6203(%rip), %rdx      # 0xe939
movb $0x0, %al
callq 0x2170
cmpl $0x1, 0x1215c(%rip)     # 0x1a8a0
jle 0x875b
movq 0x107d3(%rip), %rdi     # 0x18f20
leaq 0x221a(%rip), %rsi      # 0xa96e
movb $0x0, %al
callq 0x2110
movq 0x107be(%rip), %rdi     # 0x18f20
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq 0x21ff(%rip), %rsi      # 0xa970
movb $0x0, %al
callq 0x2110
movl $0x1, 0x1212a(%rip)     # 0x1a8ac
cmpq $0x0, -0x10(%rbp)
je 0x87b3
movq 0x10790(%rip), %rdi     # 0x18f20
movq -0x10(%rbp), %rdx
leaq 0x21e8(%rip), %rsi      # 0xa983
movb $0x0, %al
callq 0x2110
movl 0x12104(%rip), %eax     # 0x1a8ac
addl $0x1, %eax
movl %eax, 0x120fb(%rip)     # 0x1a8ac
jmp 0x87d7
movq 0x10766(%rip), %rdi     # 0x18f20
leaq 0x2068(%rip), %rsi      # 0xa829
movb $0x0, %al
callq 0x2110
movl 0x120de(%rip), %eax     # 0x1a8ac
addl $0x1, %eax
movl %eax, 0x120d5(%rip)     # 0x1a8ac
movq 0x10742(%rip), %rdi     # 0x18f20
leaq 0x2044(%rip), %rsi      # 0xa829
movb $0x0, %al
callq 0x2110
movl 0x120ba(%rip), %eax     # 0x1a8ac
addl $0x1, %eax
movl %eax, 0x120b1(%rip)     # 0x1a8ac
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: printErrorMessages
void printErrorMessages()
{
  WORD32  ix;
  WORD32  iy;

  if( listfile != NULL )
  {
    /* If any errors, display them now.                                       */
    for( iy = 0; iy < save_error_count; iy++ )
    {
      printPageBreak();
      fprintf( listfile, "%-18.18s", error_list[iy].mesg );
      if( error_list[iy].col >= 0 )
      {
        for( ix = 0; ix < error_list[iy].col; ix++ )
        {
          if( line[ix] == '\t' )
          {
            putc( '\t', listfile );
          }
          else
          {
            putc( ' ', listfile );
          }
        }
        fputs( "^", listfile );
        list_lineno++;
        page_lineno++;
      }
      fputs( "\n", listfile );
    }
  }
  save_error_count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x10660(%rip)     # 0x18f20
je 0x89f1
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x84f3(%rip), %rcx      # 0x10dcc
cmpq %rcx, %rax
jge 0x89ef
callq 0x8810
movq 0x10632(%rip), %rdi     # 0x18f20
movq -0x10(%rbp), %rcx
leaq 0x12bf7(%rip), %rax     # 0x1b4f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x1f8e(%rip), %rsi      # 0xa898
movb $0x0, %al
callq 0x2110
movq -0x10(%rbp), %rcx
leaq 0x12bd4(%rip), %rax     # 0x1b4f0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jl 0x89cb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
leaq 0x12bab(%rip), %rcx     # 0x1b4f0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jge 0x899a
movq -0x8(%rbp), %rcx
leaq 0x11f63(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x8979
movq 0x105b3(%rip), %rsi     # 0x18f20
movl $0x9, %edi
callq 0x20f0
jmp 0x898a
movq 0x105a0(%rip), %rsi     # 0x18f20
movl $0x20, %edi
callq 0x20f0
jmp 0x898c
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x8936
movq 0x1057f(%rip), %rsi     # 0x18f20
leaq 0x1ef9(%rip), %rdi      # 0xa8a1
callq 0x20c0
movl 0x11ef1(%rip), %eax     # 0x1a8a4
addl $0x1, %eax
movl %eax, 0x11ee8(%rip)     # 0x1a8a4
movl 0x11eea(%rip), %eax     # 0x1a8ac
addl $0x1, %eax
movl %eax, 0x11ee1(%rip)     # 0x1a8ac
movq 0x1054e(%rip), %rsi     # 0x18f20
leaq 0x1e50(%rip), %rdi      # 0xa829
callq 0x20c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x88ce
jmp 0x89f1
movl $0x0, 0x83d1(%rip)      # 0x10dcc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: punchLocObject
void punchLocObject( WORD32 loc, WORD32 val )
{
  if( rim_mode )
  {
    punchOrigin( loc );
  }
  punchObject(( val >> 6 ) & 0077 );
  punchObject( val & 0077 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpb $0x0, 0x630d(%rip)      # 0xed34
je 0x8a32
movq -0x8(%rbp), %rdi
callq 0x4c20
movq -0x10(%rbp), %rdi
sarq $0x6, %rdi
andq $0x3f, %rdi
callq 0x8a60
movq -0x10(%rbp), %rdi
andq $0x3f, %rdi
callq 0x8a60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: punchObject
void punchObject( WORD32 val )
{
  val &= 0377;
  if( objectfile != NULL )
  {
    fputc( val, objectfile );
    checksum += val;
  }
  binary_data_output = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0xff, %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, 0x1040e(%rip)     # 0x18e90
je 0x8aa8
movq -0x8(%rbp), %rax
movl %eax, %edi
movq 0x103ff(%rip), %rsi     # 0x18e90
callq 0x20d0
movq -0x8(%rbp), %rax
addq 0x1035f(%rip), %rax     # 0x18e00
movq %rax, 0x10358(%rip)     # 0x18e00
movb $0x1, 0x6281(%rip)      # 0xed30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: conditionFalse
void conditionFalse()
{
  int     level;

  if( line[lexstart] == '<' )
  {
    /* Invariant: line[cc] is the next unexamined character.                  */
    level = 1;
    while( level > 0 )
    {
      if( is_end( line[cc] ) || ( line[cc] == '/' ))
      {
        readLine();
      }
      else
      {
        switch( line[cc] )
        {
        case '>':
          level--;
          cc++;
          break;

        case '<':
          level++;
          cc++;
          break;

        case '$':
          level = 0;
          cc++;
          break;

        default:
          cc++;
          break;
        } /* end switch                                                       */
      } /* end if                                                             */
    } /* end while                                                            */
    nextLexeme();
  }
  else
  {
    errorMessage( &lt_expected, lexstart );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x11e39(%rip), %rcx     # 0x1aca8
leaq 0x11a4a(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
jne 0x8f88
movl $0x1, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x8f81
movq 0x11e35(%rip), %rcx     # 0x1acd0
leaq 0x11a1e(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x8ed9
movq 0x11e1e(%rip), %rcx     # 0x1acd0
leaq 0x11a07(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x8ed9
movq 0x11e07(%rip), %rcx     # 0x1acd0
leaq 0x119f0(%rip), %rax     # 0x1a8c0
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x8ee3
callq 0x4010
jmp 0x8f7c
movq 0x11de6(%rip), %rax     # 0x1acd0
leaq 0x119cf(%rip), %rcx     # 0x1a8c0
movsbl (%rax,%rcx), %eax
movl %eax, -0x8(%rbp)
subl $0x24, %eax
je 0x8f4d
jmp 0x8eff
movl -0x8(%rbp), %eax
subl $0x3c, %eax
je 0x8f30
jmp 0x8f09
movl -0x8(%rbp), %eax
subl $0x3e, %eax
jne 0x8f68
jmp 0x8f13
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movq 0x11dad(%rip), %rax     # 0x1acd0
addq $0x1, %rax
movq %rax, 0x11da2(%rip)     # 0x1acd0
jmp 0x8f7a
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movq 0x11d90(%rip), %rax     # 0x1acd0
addq $0x1, %rax
movq %rax, 0x11d85(%rip)     # 0x1acd0
jmp 0x8f7a
movl $0x0, -0x4(%rbp)
movq 0x11d75(%rip), %rax     # 0x1acd0
addq $0x1, %rax
movq %rax, 0x11d6a(%rip)     # 0x1acd0
jmp 0x8f7a
movq 0x11d61(%rip), %rax     # 0x1acd0
addq $0x1, %rax
movq %rax, 0x11d56(%rip)     # 0x1acd0
jmp 0x8f7c
jmp 0x8e8a
callq 0x4550
jmp 0x8f9b
movq 0x11d19(%rip), %rsi     # 0x1aca8
leaq 0x5b7a(%rip), %rdi      # 0xeb10
callq 0x7650
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)