LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/rules/max_file_line_numbers.c
// Function: max_file_line_numbers
unsigned int max_file_line_numbers(arraylist_t *file, unsigned int n, char *filename){

  if(file->size > n){
    char size_string[12];
    char n_string[12];
    sprintf(size_string, "%ld", file->size);
    sprintf(n_string, "%d", n);

    char *tmp0 = strconcat("Too many lines, actual: ", size_string);
    char *tmp1 = strconcat(tmp0, ", max: ");
    free(tmp0);
    tmp0 = strconcat(tmp1, n_string);

    print_warning(filename, n, NULL, tmp0);

    free(tmp1);
    free(tmp0);
    return 1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq 0x8(%rdi), %rdx
movl %esi, %ecx
xorl %eax, %eax
cmpq %rcx, %rdx
jbe 0x9427
movl %esi, %ebx
leaq 0x55f1(%rip), %rsi      # 0xe993
leaq 0x14(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2190
leaq 0x55df(%rip), %rsi      # 0xe997
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2190
leaq 0x55ca(%rip), %rdi      # 0xe99a
movq %r15, %rsi
callq 0x8026
movq %rax, %r15
leaq 0x55d1(%rip), %rsi      # 0xe9b3
movq %rax, %rdi
callq 0x8026
movq %rax, %r13
movq %r15, %rdi
callq 0x2030
movq %r13, %rdi
movq %r12, %rsi
callq 0x8026
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movq %rax, %rcx
callq 0x585c
movq %r13, %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/rules/no_multi_declaration.c
// Function: list_contains
static unsigned char list_contains(arraylist_t *list, int value) {
	for(size_t i = 0 ; i < list->size ; i++) {
		if(*(int*)arraylist_get(list, i) == value)
			return 1;
	}
	return 0;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x9629
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x6d0c
movl (%rax), %eax
cmpl %ebx, %eax
je 0x961e
incq %r15
cmpq 0x8(%r14), %r15
jb 0x9604
cmpl %ebx, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/rules/indent.c
// Function: is_expression
int is_expression(char *line, char *tmp){
    size_t index = 0;
    size_t length;
    char c;

    length = strlen(line);

    while (is_whitespace(c = line[index]) && index < length) { index++; };
    if(!strcmp(tmp, line+index)) return 1;
    return 0;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20b0
movq %rax, %r15
decq %r14
xorl %r12d, %r12d
movsbl 0x1(%r14), %edi
incq %r14
callq 0x7f3a
testb %al, %al
je 0x9972
leaq 0x1(%r12), %rax
cmpq %r15, %r12
movq %rax, %r12
jb 0x9954
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2120
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/rules/indent.c
// Function: check_expression
void check_expression(char *line, const char *expr, int *adding, int *special){
    char *tmp = NULL;
    size_t tmp_length;
    size_t index;
    char c;

    tmp = strstr(line, expr);
    index = strlen(expr);
    if(tmp) {
        if(!is_expression(line, tmp)) return;
        tmp_length = strlen(tmp);
        while (is_whitespace(c = tmp[index]) && index < tmp_length) { index++; };
        if (*adding == 0 && tmp[index] == '(') {
            (*adding) += 1;
            (*special) = 1;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
callq 0x21c0
movq %rax, %r15
movq %r12, %rdi
callq 0x20b0
testq %r15, %r15
je 0x9a0c
movq %rax, %r12
movq %r13, %rdi
movq %r15, %rsi
callq 0x9938
testl %eax, %eax
je 0x9a0c
movq %r15, %rdi
callq 0x20b0
movq %rax, %r13
movsbl (%r15,%r12), %edi
callq 0x7f3a
leaq 0x1(%r12), %rcx
testb %al, %al
je 0x99f4
cmpq %r13, %r12
movq %rcx, %r12
jb 0x99d9
cmpl $0x0, (%r14)
jne 0x9a0c
cmpb $0x28, -0x1(%r15,%rcx)
jne 0x9a0c
movl $0x1, %eax
movl %eax, (%r14)
movl %eax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/rules/comma_spacing.c
// Function: comma_spacing
unsigned int comma_spacing(arraylist_t *buffer, arraylist_t *real_file){
    char *line = NULL;
    size_t length;
    unsigned int counter = 0;
    line_t *e;
    char *display = NULL;
    unsigned int breaks = 0;

    for(size_t i = 0; i < buffer->size; i++){
        e = get_line(buffer, i);
        line = str_remove_comments(e->line);
        length = strlen(line);
        for(size_t j = 0; j < length; j++){
            if(line[j] == ',' && !check_quotes(line, line+j, (int)length) && line[j+1] != ' '){
                counter++;
                breaks = strcount_heading_line_breaks(e->line) + (e->start_real_line == 0 ? 1 : 0);
                display = trim(arraylist_get(real_file, e->start_real_line + breaks - 1));
                print_warning(e->source, e->start_real_line + breaks, display, "No space after a comma");
                free(display);
            }
        }
        free(line);
    }
    return counter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x8(%rdi)
je 0x9b1b
xorl %esi, %esi
movl $0x0, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
callq 0x2a78
movq %rax, %r12
movq (%rax), %rdi
callq 0x7c54
movq %rax, %r13
movq %rax, %rdi
callq 0x20b0
testq %rax, %rax
je 0x9afa
movq %rax, %rbx
xorl %r15d, %r15d
cmpb $0x2c, (%r13,%r15)
jne 0x9aee
leaq (%r15,%r13), %rsi
movq %r13, %rdi
movl %ebx, %edx
callq 0x82dc
testb %al, %al
jne 0x9aee
cmpb $0x20, 0x1(%r13,%r15)
je 0x9aee
movq (%r12), %rdi
callq 0x7f5c
movl %eax, %r14d
movl 0x10(%r12), %ebp
movl %ebp, %esi
subl $0x1, %esi
adcl %eax, %esi
movq 0x18(%rsp), %rdi
callq 0x6d0c
movq %rax, %rdi
callq 0x8239
cmpl $0x1, %ebp
adcl 0x10(%r12), %r14d
movq %rax, %rbp
incl 0xc(%rsp)
movq 0x8(%r12), %rdi
movl %r14d, %esi
movq %rax, %rdx
leaq 0x4f0a(%rip), %rcx      # 0xe9eb
callq 0x585c
movq %rbp, %rdi
callq 0x2030
incq %r15
cmpq %r15, %rbx
jne 0x9a74
movq %r13, %rdi
callq 0x2030
movq 0x20(%rsp), %rsi
incq %rsi
movq 0x10(%rsp), %rdi
cmpq 0x8(%rdi), %rsi
jb 0x9a45
jmp 0x9b23
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/rules/max_line_numbers.c
// Function: check_max_line_length
unsigned int check_max_line_length(arraylist_t *file, unsigned int n, char *filename){
	unsigned int counter = 0;

	for(unsigned int i = 0; i < file->size; i++){
		counter += line_length_check(arraylist_get(file, i), n, i, filename);
	}
	return counter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x18(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x8(%rdi)
je 0x9e45
movq %rdi, %r14
movl 0xc(%rsp), %ebp
movl $0x1, %r15d
xorl %esi, %esi
xorl %r13d, %r13d
movq %rdi, 0x10(%rsp)
movq %r14, %rdi
callq 0x6d0c
movq %rax, %r12
movq %rax, %rdi
callq 0x20b0
movl $0x0, %ecx
testq %rax, %rax
je 0x9e30
xorl %ecx, %ecx
cmpb $0xa, -0x1(%r12,%rax)
sete %cl
subq %rcx, %rax
movl $0x0, %ecx
cmpq %rbp, %rax
jbe 0x9e30
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
leaq 0x4c06(%rip), %rsi      # 0xe993
movq %rax, %rdx
xorl %eax, %eax
callq 0x2190
leaq 0x24(%rsp), %rdi
leaq 0x4bf4(%rip), %rsi      # 0xe997
movl 0xc(%rsp), %edx
xorl %eax, %eax
callq 0x2190
leaq 0x4c76(%rip), %rdi      # 0xea2b
movq %rbx, %rsi
callq 0x8026
movq %rax, %rbx
movq %rax, %rdi
leaq 0x4be9(%rip), %rsi      # 0xe9b3
callq 0x8026
movq %rbp, %r14
movq %rax, %rbp
movq %rbx, %rdi
callq 0x2030
movq %rbp, %rdi
leaq 0x24(%rsp), %rsi
callq 0x8026
movq %rax, %rbx
movq %rbp, %rdi
movq %r14, %rbp
movq 0x10(%rsp), %r14
callq 0x2030
movq %r12, %rdi
callq 0x8239
movq %rax, %r12
movq 0x18(%rsp), %rdi
movl %r15d, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x585c
movq %rbx, %rdi
callq 0x2030
movq %r12, %rdi
callq 0x2030
movl $0x1, %ecx
addl %ecx, %r13d
movl %r15d, %esi
incl %r15d
cmpq %rsi, 0x8(%r14)
ja 0x9d41
jmp 0x9e48
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/rules/parsing.c
// Function: fill_variables_list
static void fill_variables_list(scope_t *scope, arraylist_t *variables) {
	node_t  *current = scope->children->head;
	field_t *field   = NULL;

	for(size_t i = 0 ; i < scope->variables->size ; i++) {
		field = arraylist_get(scope->variables, i);
		arraylist_add(variables, field);
	}

	if(current != NULL) {
		do {
			fill_variables_list((scope_t*)current->val, variables);
		} while ((current = current->next) != NULL);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rdi
movq 0x8(%rax), %r12
cmpq $0x0, 0x8(%rdi)
je 0xaa09
xorl %r15d, %r15d
movq %r15, %rsi
callq 0x6d0c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6c26
incq %r15
movq 0x18(%r14), %rdi
cmpq 0x8(%rdi), %r15
jb 0xa9d6
jmp 0xaa09
movq (%r12), %rdi
movq %rbx, %rsi
callq 0xa9b2
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xa9f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
leaq 0x423c(%rip), %rcx      # 0xec6c
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
movq (%rbx), %rax
movq (%rax), %rsi
callq 0x8026
movq %rax, %r14
movq (%rbx), %rax
movsbl 0x8(%rax), %esi
movl $0x2a, %edi
callq 0x84fc
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x8026
movq %rax, %r12
movq %r15, %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
cmpl $0x2, %ebp
leaq 0x41d2(%rip), %rax      # 0xec53
leaq 0x41d7(%rip), %rsi      # 0xec5f
cmoveq %rax, %rsi
movq %r12, %rdi
callq 0x8026
movq %rax, %r14
movq %r12, %rdi
callq 0x2030
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x8026
movq %rax, %r15
movq %r14, %rdi
callq 0x2030
movq 0x8(%rbx), %rax
movsbl 0x8(%rax), %esi
movl $0x2a, %edi
callq 0x84fc
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x8026
movq %rax, %r14
movq %rbx, %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xab49
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d0c
movq %rax, %r15
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2030
movq (%r15), %rdi
callq 0x2030
movq 0x8(%r15), %rax
movq (%rax), %rdi
callq 0x2030
movq 0x8(%r15), %rdi
callq 0x2030
incq %r14
cmpq 0x8(%rbx), %r14
jb 0xab0a
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x6d97
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0xabcc
movq %rdi, %r15
movq %rsi, (%rsp)
xorl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0x6d0c
movq %rax, %r12
movq %rax, %rdi
callq 0x20b0
movq %rax, %r13
movslq %r13d, %rbp
xorl %ebx, %ebx
movsbl (%r12,%rbx), %edi
callq 0x7f3a
leaq 0x1(%rbx), %rcx
testb %al, %al
je 0xabb0
cmpq %rbp, %rbx
movq %rcx, %rbx
jl 0xab96
leal -0x1(%rcx), %eax
decl %r13d
cmpl %eax, %r13d
jg 0xabd1
incq %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
jb 0xab78
movl %eax, %r14d
jmp 0xabe5
xorl %r14d, %r14d
jmp 0xabe9
cmpb $0x2f, -0x1(%r12,%rcx)
jne 0xabe2
xorl %eax, %eax
cmpb $0x2a, (%r12,%rcx)
je 0xac02
incl %r14d
movq (%rsp), %rsi
leaq 0x4088(%rip), %rcx      # 0xec78
movq %rsi, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x585c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/parsing_functions.c
// Function: check_function_call_parameters
void check_function_call_parameters(scope_t *scope, function_t *call, function_t *function, int line_index, messages_t *messages) {
	field_t *field            = NULL;
	field_t *param            = NULL;
	invalid_call_t *error     = NULL;
	type_t type;

	if(function != NULL && call->params->size != function->params->size && messages->invalid_calls != NULL) {
		error = malloc(sizeof(invalid_call_t));
		error->name = strduplicate(function->name);
		error->more = call->params->size - function->params->size;
		arraylist_add(messages->invalid_calls, error);
	}

	for(size_t i = 0 ; i < call->params->size ; i++) {

		field = arraylist_get(call->params, i);

		type = parse_expression(field->name, line_index, scope, messages);
		if(!strcmp(type.name, "NULL")) {
			type = parse_operation(field->name, line_index, scope, messages);
		}

		if(function != NULL && i < function->params->size) {
			param = arraylist_get(function->params, i);
			if(strcmp(type.name, "NULL") && !type_equals(&type, &(param->type))) {
				arraylist_add(messages->invalid_params, field_init(strduplicate(field->name), strduplicate(field->type.name), field->type.is_pointer, field->line));
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movl %ecx, 0x4(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0xb650
movq 0x20(%r12), %rax
movq 0x8(%rax), %rax
movq 0x20(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0xb650
cmpq $0x0, 0x18(%rbx)
je 0xb650
movl $0x10, %edi
callq 0x2140
movq %rax, %r15
movq (%r14), %rdi
callq 0x7dc1
movq %rax, (%r15)
movq 0x20(%r12), %rax
movl 0x8(%rax), %eax
movq 0x20(%r14), %rcx
subl 0x8(%rcx), %eax
movl %eax, 0x8(%r15)
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x6c26
movq 0x20(%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0xb751
xorl %r13d, %r13d
movq %r13, %rsi
callq 0x6d0c
movq %rax, %r15
movq (%rax), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0xb780
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, %rdi
leaq 0x321a(%rip), %rsi      # 0xe8b0
callq 0x2120
testl %eax, %eax
jne 0xb6bd
movq (%r15), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x70b0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
testq %r14, %r14
je 0xb73f
movq 0x20(%r14), %rdi
cmpq 0x8(%rdi), %r13
jae 0xb73f
movq %r13, %rsi
callq 0x6d0c
movq %rax, %rbp
movq 0x10(%rsp), %rdi
leaq 0x31cd(%rip), %rsi      # 0xe8b0
callq 0x2120
testl %eax, %eax
je 0xb73f
addq $0x10, %rbp
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x686e
testb %al, %al
jne 0xb73f
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rsp)
movq (%r15), %rdi
callq 0x7dc1
movq %rax, %rbp
movq 0x10(%r15), %rdi
callq 0x7dc1
movsbl 0x18(%r15), %edx
movl 0x20(%r15), %ecx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x615c
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x6c26
incq %r13
movq 0x20(%r12), %rdi
cmpq 0x8(%rdi), %r13
jb 0xb663
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movslq %esi, %r15
addq %r15, %rdi
movl $0x3b, %esi
callq 0x7fba
addl %eax, %r15d
cmpl $-0x1, %r15d
je 0xcba2
movslq %r15d, %r12
leaq (%r14,%r12), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x82dc
testb %al, %al
je 0xcba8
leaq (%r12,%r14), %rdi
incq %rdi
movl $0x3b, %esi
callq 0x7fba
leal (%r12,%rax), %r15d
incl %r15d
jmp 0xcb6d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: defineSymbol
SYM_T *defineSymbol( char *name, WORD32 val, SYMTYP type, WORD32 start )
{
  SYM_T  *sym;
  WORD32  xref_count;

  val = val & 07777;
  if( strlen( name ) < 1 )
  {
    return( &sym_undefined );   /* Protect against non-existent names.        */
  }
  sym = lookup( name );
  xref_count = 0;               /* Set concordance for normal defintion.      */

  if( M_DEFINED( sym->type ) && sym->val != val && M_NOTRDEF( sym -> type ))
  {
    if( pass == 2 )
    {
      errorSymbol( &redefined_symbol, sym->name, start );
      type = type | REDEFINED;
      sym->xref_count++;      /* Referenced symbol, count it.                */
      xref_count = sym->xref_count;
    }
  return ( sym );
  }
  if( M_FIXED( sym->type ))
  {
  return ( sym );
  }

  if( pass == 2 && xref )
  {
    /* Put the definition line number in the concordance table.               */
    /* Defined symbols are not counted as references.                         */
    xreftab[sym->xref_index] = lineno;
    /* Put the line number in the concordance table.                          */
    xreftab[sym->xref_index + xref_count] = lineno;
  }

  /* Now set the value and the type.                                          */
  sym->val = val;
  sym->type = ( pass == 1 ) ? ( type | CONDITION ) : type;
  return( sym );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x2bc1
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
andl $0xfff, %r14d           # imm = 0xFFF
callq 0x4109
movq %rax, %rbx
movl (%rax), %eax
testb $0x1, %al
jne 0x2bd6
testb $0x2, %al
jne 0x2bc8
movq 0xc1ba(%rip), %rax      # 0xed30
cmpq $0x2, %rax
jne 0x2baa
cmpb $0x0, 0xa113(%rip)      # 0xcc96
je 0x2baa
movslq 0x15c70(%rip), %rax     # 0x187fc
movq 0x142fd(%rip), %rcx     # 0x16e90
movq 0x18(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x18(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0xc186(%rip), %rax      # 0xed30
movq %r14, 0x10(%rbx)
movl %ebp, %ecx
orl $0x80, %ecx
cmpq $0x1, %rax
cmovnel %ebp, %ecx
movl %ecx, (%rbx)
jmp 0x2bc8
leaq 0xa090(%rip), %rbx      # 0xcc58
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl $0x14e, %eax            # imm = 0x14E
je 0x2b6b
cmpq %r14, 0x10(%rbx)
je 0x2b6b
cmpq $0x2, 0xc145(%rip)      # 0xed30
jne 0x2bc8
movq %rbx, %rsi
addq $0x4, %rsi
leaq 0x9e55(%rip), %rdi      # 0xca50
movq %r15, %rdx
callq 0x42b6
incq 0x20(%rbx)
jmp 0x2bc8
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
movl $0xf0, %ebx
cmovneq %rdi, %rbx
cmpq $0x0, 0x13c85(%rip)     # 0x16df0
sete %al
testq %rbx, %rbx
setle %cl
orb %al, %cl
jne 0x318e
movq 0x13c71(%rip), %rsi     # 0x16df0
movl $0x80, %edi
callq 0x20e0
decq %rbx
jne 0x3178
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: printMemoryMap
void printMemoryMap()
{
  WORD32 loc;
  int i, j, k;

  page_lineno = 0;
  list_lineno = 0;

  /* loop from loc 0 to maximum address used */
  for( loc = 0; loc <= memory_max; )
  {

    /* force a new page halfway thru the field */
    if( (loc & 03777) == 00000 ) page_lineno = LIST_LINES_PER_PAGE;
    if( page_lineno >= LIST_LINES_PER_PAGE )
    {
      topOfForm( list_title, s_memmap );
    }

    /* print two halves of a page over two lines */
    for( i = 0; i < 2; ++i )
    {
      page_lineno++;
      list_lineno++;
      fprintf( listfile, "%5d %05o/", list_lineno, (unsigned)loc );
      /* print 8 groups per line */
      for( j = 0; j < 8; ++j )
      {
	fprintf( listfile, " " );
	/* print 8 words per group */
	for( k = 0; k < 8; ++k )
	{
	  fprintf( listfile, "%c", memory_map[loc++] ? 'X' : '.');
	}
      }
      fprintf( listfile, "\n" );
    }

    page_lineno++;
    list_lineno++;
    fprintf( listfile, "%5d\n", list_lineno );
  }

}

// Assembly:
xorl %eax, %eax
movl %eax, 0x1512a(%rip)     # 0x1880c
movl %eax, 0x1511c(%rip)     # 0x18804
cmpq $0x0, 0x13668(%rip)     # 0x16d58
js 0x381d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x52b6(%rip), %r15      # 0x89be
leaq 0xb641(%rip), %rbp      # 0xed50
xorl %r13d, %r13d
movq %r13, %rax
shlq $0x35, %rax
je 0x3726
cmpl $0x3c, 0x150ea(%rip)    # 0x1880c
jge 0x3730
jmp 0x3743
movl $0x3c, 0x150dc(%rip)    # 0x1880c
leaq 0x15929(%rip), %rdi     # 0x19060
leaq 0x9232(%rip), %rsi      # 0xc970
callq 0x6998
movb $0x1, %bl
incl 0x150c1(%rip)           # 0x1880c
movl 0x150b3(%rip), %edx     # 0x18804
incl %edx
movl %edx, 0x150ab(%rip)     # 0x18804
movq 0x13720(%rip), %rdi     # 0x16e80
xorl %r14d, %r14d
movq %r15, %rsi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x2120
movq 0x13709(%rip), %rsi     # 0x16e80
movl $0x20, %edi
callq 0x20e0
movl $0x8, %r12d
movq 0x136f2(%rip), %rsi     # 0x16e80
cmpb $0x0, (%r13,%rbp)
movl $0x2e, %edi
je 0x37a0
movl $0x58, %edi
incq %r13
callq 0x20e0
decl %r12d
jne 0x3787
incl %r14d
cmpl $0x8, %r14d
jne 0x3770
movq 0x136c3(%rip), %rsi     # 0x16e80
movl $0xa, %edi
callq 0x20e0
testb $0x1, %bl
movl $0x0, %ebx
jne 0x3745
incl 0x15031(%rip)           # 0x1880c
movl 0x15023(%rip), %edx     # 0x18804
incl %edx
movl %edx, 0x1501b(%rip)     # 0x18804
movq 0x13690(%rip), %rdi     # 0x16e80
leaq 0x51d1(%rip), %rsi      # 0x89c8
xorl %eax, %eax
callq 0x2120
leaq -0x1(%r13), %rax
cmpq 0x1354f(%rip), %rax     # 0x16d58
jl 0x3712
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: nextLexeme
void nextLexeme()
{
  /* Save start column of previous lexeme for diagnostic messages.            */
  lexstartprev = lexstart;
  lextermprev = lexterm;

  while( is_blank( line[cc] )) { cc++; }
  lexstart = cc;

  if( is_alnum( line[cc] ))
  {
    while( is_alnum( line[cc] )) { cc++; }
  }
  else if( is_end( line[cc] ))
  {
    /* End-of-Line, don't advance cc!                                         */
  }
  else
  {
    switch( line[cc] )
    {
    case '"':     /* Quoted letter                                            */
      if( cc + 2 < maxcc )
      {
        cc++;
        cc++;
      }
      else
      {
        errorMessage( &no_literal_value, lexstart );
        cc++;
      }
      break;

    case '/':     /* Comment, don't advance cc!                               */
      break;

    default:      /* All other punctuation.                                   */
      cc++;
      break;
    }
  }
  lexterm = cc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x15126(%rip), %rax     # 0x18c08
movq %rax, 0x1513f(%rip)     # 0x18c28
movq 0x15128(%rip), %rax     # 0x18c18
movq %rax, 0x17b31(%rip)     # 0x1b628
movq 0x15132(%rip), %rbx     # 0x18c30
leaq 0x14d1b(%rip), %r14     # 0x18820
movabsq $0x4000000100001200, %rax # imm = 0x4000000100001200
movzbl (%rbx,%r14), %ecx
cmpq $0x3e, %rcx
ja 0x3b2c
btq %rcx, %rax
jae 0x3b2c
incq %rbx
movq %rbx, 0x15106(%rip)     # 0x18c30
jmp 0x3b0f
movsbq %cl, %r15
movq %rbx, 0x150d1(%rip)     # 0x18c08
callq 0x21a0
movq (%rax), %rcx
testb $0x8, (%rcx,%r15,2)
jne 0x3b5a
movzbl %r15b, %eax
cmpl $0x21, %eax
jg 0x3b83
testl %eax, %eax
je 0x3b76
cmpl $0xa, %eax
je 0x3b76
jmp 0x3bb5
movq %rbx, %rax
movsbq 0x1(%rax,%r14), %rdx
incq %rax
testb $0x8, (%rcx,%rdx,2)
jne 0x3b5d
movq %rax, 0x150bd(%rip)     # 0x18c30
movq %rax, %rbx
movq %rbx, 0x1509b(%rip)     # 0x18c18
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x2f, %eax
je 0x3b76
cmpl $0x22, %eax
jne 0x3bb5
leaq 0x2(%rbx), %rax
cmpq 0x154a0(%rip), %rax     # 0x19038
jl 0x3b6c
leaq 0x8f4f(%rip), %rdi      # 0xcaf0
movq %rbx, %rsi
callq 0x5cac
movq 0x15080(%rip), %rax     # 0x18c30
incq %rax
jmp 0x3b6c
incq %rbx
movq %rbx, %rax
jmp 0x3b6c
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x133eb(%rip), %rsi     # 0x16fb0
decq %rsi
leaq 0x14411(%rip), %rdi     # 0x17fe0
callq 0x3e30
movq 0x133dd(%rip), %rsi     # 0x16fb8
leaq 0x14806(%rip), %rdi     # 0x183e8
callq 0x3e30
cmpb $0x0, 0x15022(%rip)     # 0x18c10
je 0x3bf6
popq %rax
jmp 0x6971
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
andq $0xf80, %r13            # imm = 0xF80
sete %al
leaq 0x14599(%rip), %rcx     # 0x183e8
cmpq %rcx, %rdi
setne %cl
testb %al, %cl
jne 0x3f10
shrl $0x7, %esi
movzbl %sil, %ebp
leal (,%rbp,8), %eax
leaq 0x1395e(%rip), %r15     # 0x177d0
movq (%rax,%r15), %r14
leaq 0x13153(%rip), %r12     # 0x16fd0
movq (%rax,%r12), %rax
cmpq %rax, %r14
jge 0x3f10
movq %rdi, %rbx
cmpb $0x0, 0x8e00(%rip)      # 0xcc94
jne 0x3eb0
orq %r13, %r14
movq %r14, %rdi
callq 0x3f1f
leal (,%rbp,8), %eax
movq (%rax,%r15), %r14
movq (%rax,%r12), %rax
cmpq %rax, %r14
jge 0x3ef5
movq %r12, %r15
leaq (%r14,%r13), %r12
movq 0x130f5(%rip), %rsi     # 0x16fb8
orq %r12, %rsi
movq 0x8(%rbx,%r14,8), %rdx
leaq 0x1494e(%rip), %rdi     # 0x18820
movl $0x3, %ecx
callq 0x3f83
movq 0x8(%rbx,%r14,8), %rsi
movq %r12, %rdi
movq %r15, %r12
callq 0x6be8
incq %r14
cmpq (%r15,%rbp,8), %r14
jl 0x3eb5
movq $0x0, (%rbx)
shll $0x3, %ebp
leaq 0x138ca(%rip), %rax     # 0x177d0
movq (%rbp,%rax), %rax
movq %rax, (%rbp,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10193(%rip), %rsi     # 0x16df0
testq %rsi, %rsi
je 0x6c76
pushq %rbx
movzbl %dil, %ebx
movl %ebx, %edi
callq 0x20e0
addq %rbx, 0x100eb(%rip)     # 0x16d60
popq %rbx
movb $0x1, 0x6013(%rip)      # 0xcc90
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdx, %rsi
jge 0x428f
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1(%rsi), %r12
xorl %r13d, %r13d
leaq (%r12,%r13), %rbp
leaq (%r15,%r13), %rax
leaq 0x145b2(%rip), %rcx     # 0x18820
movsbl (%rcx,%rax), %edi
callq 0x2080
leaq 0x1(%r13), %rcx
movb %al, (%rbx,%r13)
cmpq %r14, %rbp
jge 0x4291
cmpq $0x5, %r13
movq %rcx, %r13
jb 0x425f
jmp 0x4291
xorl %ecx, %ecx
leaq (%rbx,%rcx), %rdi
movl $0x7, %edx
subq %rcx, %rdx
xorl %esi, %esi
callq 0x20d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x2, 0xaa72(%rip)      # 0xed30
jne 0x434e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x45b3(%rip), %r15      # 0x8892
cmovneq %rsi, %r15
incl 0xaa3f(%rip)            # 0xed28
movl 0x1450d(%rip), %edx     # 0x187fc
leaq 0x1(%rbx), %rcx
leaq 0x46f2(%rip), %rsi      # 0x89ec
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x2170
movq 0xaa10(%rip), %rdi      # 0xed20
movq 0x8(%r14), %r8
movl 0x12c96(%rip), %eax     # 0x16fb0
movl %eax, (%rsp)
leaq 0x46d1(%rip), %rsi      # 0x89f5
leaq 0x12c05(%rip), %rdx     # 0x16f30
movq %r12, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x70a2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movb $0x1, 0x148bb(%rip)     # 0x18c10
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq 0x1461d(%rip), %rsi     # 0x18c08
movq 0x14626(%rip), %rdx     # 0x18c18
leaq 0x9(%rsp), %rbx
movq %rbx, %rdi
callq 0x423f
movq %rbx, %rdi
callq 0x4109
movq 0x20(%rax), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
cmpb $0x0, 0x867c(%rip)      # 0xcc96
je 0x4641
cmpq $0x2, 0xa70c(%rip)      # 0xed30
jne 0x4641
movslq 0x141cf(%rip), %rdx     # 0x187fc
movq 0x18(%rax), %rsi
shlq $0x3, %rsi
addq 0x12854(%rip), %rsi     # 0x16e90
movq %rdx, 0x8(%rsi,%rcx,8)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x117e6(%rip), %ecx     # 0x16fb8
shrl $0x4, %ecx
andl $0x7f8, %ecx            # imm = 0x7F8
leaq 0x11fee(%rip), %rax     # 0x177d0
movq (%rcx,%rax), %rax
leaq 0x117e3(%rip), %rdx     # 0x16fd0
movq (%rcx,%rdx), %rcx
cmpq %rcx, %rax
jge 0x580c
leaq 0x12beb(%rip), %rdx     # 0x183e8
cmpq %rdi, 0x8(%rdx,%rax,8)
je 0x580f
incq %rax
cmpq %rax, %rcx
jne 0x57fd
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x2, 0x907c(%rip)      # 0xed30
jne 0x5d27
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
incl 0x905d(%rip)            # 0xed28
movl 0x12b2b(%rip), %edx     # 0x187fc
leaq 0x1(%rsi), %rcx
leaq 0x2d10(%rip), %rsi      # 0x89ec
movq %rsp, %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2170
movq 0x9030(%rip), %rdi      # 0xed20
movq 0x8(%r14), %r8
movl 0x112b5(%rip), %r9d     # 0x16fb0
leaq 0x2d1c(%rip), %rsi      # 0x8a1e
leaq 0x11227(%rip), %rdx     # 0x16f30
movq %r15, %rcx
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x70a2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, 0x12ee2(%rip)     # 0x18c10
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x12efa(%rip), %rax     # 0x18c30
leaq 0x12ae3(%rip), %rcx     # 0x18820
movzbl (%rax,%rcx), %edx
testl %edx, %edx
je 0x5d56
cmpl $0xa, %edx
je 0x5d56
incq %rax
movq %rax, 0x12edc(%rip)     # 0x18c30
jmp 0x5d3d
movq %rax, 0x12eab(%rip)     # 0x18c08
movq %rax, 0x12eb4(%rip)     # 0x18c18
movq %rax, 0x12ebd(%rip)     # 0x18c28
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movb $0x0, 0x12f06(%rip)     # 0x19040
movq 0x12ad7(%rip), %r14     # 0x18c18
leaq 0x126d8(%rip), %r12     # 0x18820
movb (%r14,%r12), %al
movb %al, 0x12ace(%rip)      # 0x18c20
movq 0x12aaf(%rip), %rbx     # 0x18c08
cmpq %r14, %rbx
jge 0x6197
callq 0x21a0
movq (%rax), %rdx
movsbq (%rbx,%r12), %rcx
testb $0x8, 0x1(%rdx,%rcx,2)
je 0x619c
leaq (%r15,%r15,4), %rdx
leaq (%rcx,%rdx,2), %rcx
addq $-0x30, %rcx
cmpq %r15, %rcx
jge 0x618a
movb $0x1, 0x12eb6(%rip)     # 0x19040
incq %rbx
movq %rcx, %r15
cmpq %r14, %rbx
jl 0x6163
jmp 0x61c7
movq %r15, %rcx
jmp 0x61c7
movq 0x12a65(%rip), %rsi     # 0x18c08
leaq 0x1(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x423f
leaq 0x6816(%rip), %rdi      # 0xc9d0
movq %r15, %rsi
movq %rbx, %rdx
callq 0x42b6
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl %edi, %eax
shrl $0x7, %eax
movzbl %al, %ecx
andl $0x7f, %edi
testl %ecx, %ecx
je 0x6937
leaq 0x10ebb(%rip), %rdx     # 0x177d0
xorl %eax, %eax
cmpq (%rdx,%rcx,8), %rdi
jl 0x696f
cmpq $0x0, 0x116bb(%rip)     # 0x17fe0
jne 0x696f
leaq 0x116b2(%rip), %rbx     # 0x17fe0
leaq 0x612b(%rip), %rdi      # 0xca60
jmp 0x695a
xorl %eax, %eax
cmpq 0x10e90(%rip), %rdi     # 0x177d0
jl 0x696f
cmpq $0x0, 0x11a9e(%rip)     # 0x183e8
jne 0x696f
leaq 0x11a95(%rip), %rbx     # 0x183e8
leaq 0x6116(%rip), %rdi      # 0xca70
movq $-0x1, %rsi
callq 0x5cac
movq $0x1, (%rbx)
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, 0x104e0(%rip)     # 0x16e80
je 0x6a88
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x11e42(%rip), %ebp     # 0x18800
incl %ebp
movl %ebp, 0x11e3a(%rip)     # 0x18800
leaq 0x5f7c(%rip), %r15      # 0xc949
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2070
leaq 0x1feb(%rip), %rsi      # 0x89cd
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2170
cmpl $0x2, 0x11e08(%rip)     # 0x18800
jl 0x6a0b
movq 0x1047f(%rip), %rsi     # 0x16e80
movl $0xc, %edi
callq 0x20e0
movq 0x1046e(%rip), %rdi     # 0x16e80
leaq 0x1fba(%rip), %rsi      # 0x89d3
movq %rsp, %rcx
movq %r14, %rdx
xorl %eax, %eax
callq 0x2120
movl $0x1, 0x11ddc(%rip)     # 0x1880c
movq 0x10449(%rip), %rax     # 0x16e80
testq %rbx, %rbx
je 0x6a52
leaq 0x1fa3(%rip), %rsi      # 0x89e6
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
jmp 0x6a5f
movl $0xa, %edi
movq %rax, %rsi
callq 0x20e0
incl 0x11da7(%rip)           # 0x1880c
movq 0x10414(%rip), %rsi     # 0x16e80
movl $0xa, %edi
callq 0x20e0
incl 0x11d90(%rip)           # 0x1880c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, 0x10382(%rip)     # 0x16e80
je 0x6bdd
cmpl $0x0, 0x8221(%rip)      # 0xed2c
jle 0x6bdd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1292d(%rip), %r12     # 0x19450
leaq 0x11cf6(%rip), %r13     # 0x18820
leaq 0x1d60(%rip), %r15      # 0x8891
xorl %ebp, %ebp
callq 0x6a89
movq 0x10341(%rip), %rdi     # 0x16e80
movq %rbp, %rbx
shlq $0x4, %rbx
leaq (%r12,%rbx), %r14
movq (%rbx,%r12), %rdx
leaq 0x1dab(%rip), %rsi      # 0x8900
xorl %eax, %eax
callq 0x2120
cmpq $0x0, 0x8(%rbx,%r12)
js 0x6bad
je 0x6b8e
xorl %ebx, %ebx
cmpb $0x9, (%rbx,%r13)
movl $0x9, %edi
je 0x6b79
movl $0x20, %edi
movq 0x10300(%rip), %rsi     # 0x16e80
callq 0x2100
incq %rbx
cmpq 0x8(%r14), %rbx
jl 0x6b68
movq 0x102eb(%rip), %rsi     # 0x16e80
leaq 0x1d6d(%rip), %rdi      # 0x8909
callq 0x20c0
incl 0x11c5d(%rip)           # 0x18804
incl 0x11c5f(%rip)           # 0x1880c
movq 0x102cc(%rip), %rsi     # 0x16e80
movq %r15, %rdi
callq 0x20c0
incq %rbp
movslq 0x8166(%rip), %rax      # 0xed2c
cmpq %rax, %rbp
jl 0x6b33
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0x0, 0x8145(%rip)      # 0xed2c
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, 0x609e(%rip)      # 0xcc94
je 0x6bfd
callq 0x3f1f
movq 0x101ec(%rip), %rsi     # 0x16df0
testq %rsi, %rsi
je 0x6c47
movl %ebx, %r14d
shrl $0x6, %r14d
andl $0x3f, %r14d
movl %r14d, %edi
callq 0x20e0
addq %r14, 0x1013d(%rip)     # 0x16d60
movq 0x101c6(%rip), %rsi     # 0x16df0
movb $0x1, 0x605f(%rip)      # 0xcc90
testq %rsi, %rsi
je 0x6c47
andl $0x3f, %ebx
movl %ebx, %edi
callq 0x20e0
addq %rbx, 0x10119(%rip)     # 0x16d60
movb $0x1, 0x6042(%rip)      # 0xcc90
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq 0x11c19(%rip), %rsi     # 0x18c08
leaq 0x1182a(%rip), %rbx     # 0x18820
cmpb $0x3c, (%rsi,%rbx)
jne 0x705f
movl $0x1, %ebp
movq 0x11c28(%rip), %rax     # 0x18c30
movzbl (%rax,%rbx), %ecx
cmpl $0x2e, %ecx
jle 0x7022
cmpl $0x3e, %ecx
je 0x7039
cmpl $0x3c, %ecx
je 0x703d
cmpl $0x2f, %ecx
je 0x702b
jmp 0x7046
testl %ecx, %ecx
je 0x702b
cmpl $0xa, %ecx
jne 0x7041
callq 0x381e
movq 0x11bf9(%rip), %rax     # 0x18c30
jmp 0x7050
decl %ebp
jmp 0x7046
incl %ebp
jmp 0x7046
cmpl $0x24, %ecx
je 0x7071
incq %rax
movq %rax, 0x11be0(%rip)     # 0x18c30
testl %ebp, %ebp
jne 0x7008
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3ad6
leaq 0x5aba(%rip), %rdi      # 0xcb20
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5cac
incq %rax
movq %rax, 0x11bb5(%rip)     # 0x18c30
jmp 0x7054
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: saveError
void saveError( char *mesg, WORD32 col )
{
  if( save_error_count < DIM( error_list ))
  {
    error_list[save_error_count].mesg = mesg;
    error_list[save_error_count].col = col;
    save_error_count++;
  }
  error_in_line = TRUE;

  if( listed )
  {
    printErrorMessages();
  }
}

// Assembly:
movl 0x7c84(%rip), %eax      # 0xed2c
cmpq $0x13, %rax
ja 0x70cd
movq %rax, %rcx
shlq $0x4, %rcx
leaq 0x12394(%rip), %rdx     # 0x19450
movq %rdi, (%rcx,%rdx)
movq %rsi, 0x8(%rcx,%rdx)
incl %eax
movl %eax, 0x7c5f(%rip)      # 0xed2c
movb $0x1, 0x11b3c(%rip)     # 0x18c10
cmpq $0x0, 0x11714(%rip)     # 0x187f0
jne 0x6af6
retq