LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/combine.c
// Function: translate_literal
static unsigned translate_literal(const aiger* implementation, unsigned literal, unsigned offset) {
    unsigned tag = aiger_lit2tag(implementation, literal);
    if (tag == 0) {
        // constant
        return literal;
    } else if (tag == 1) {
        // input
        aiger_symbol* input = aiger_is_input(implementation, aiger_strip(literal));
        assert(input != NULL);
        assert(input->next != 0);
        return literal % 2 == 1 ? aiger_not(input->next) : input->next;
    } else if (tag == 2) {
        // latch
        return literal + offset * 2;
    } else {
        assert(tag == 3);
        // and
        return literal + offset * 2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9c10
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1fa2
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2087
cmpl $0x1, -0x1c(%rbp)
jne 0x203e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
andl $-0x2, %esi
callq 0x9d30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1fc8
jmp 0x1fe7
leaq 0xa249(%rip), %rdi      # 0xc218
leaq 0xa156(%rip), %rsi      # 0xc12c
movl $0x8f, %edx
leaq 0xa244(%rip), %rcx      # 0xc226
callq 0x10f0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x1ff3
jmp 0x2012
leaq 0xa276(%rip), %rdi      # 0xc270
leaq 0xa12b(%rip), %rsi      # 0xc12c
movl $0x90, %edx
leaq 0xa219(%rip), %rcx      # 0xc226
callq 0x10f0
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x202c
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
xorl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2036
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2087
cmpl $0x2, -0x1c(%rbp)
jne 0x2053
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x2087
cmpl $0x3, -0x1c(%rbp)
jne 0x205b
jmp 0x207a
leaq 0xa21f(%rip), %rdi      # 0xc281
leaq 0xa0c3(%rip), %rsi      # 0xc12c
movl $0x96, %edx
leaq 0xa1b1(%rip), %rcx      # 0xc226
callq 0x10f0
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_delete_comments
static unsigned
aiger_delete_comments (aiger * public)
{
  char **start = (char **) public->comments, ** end, ** p;
  IMPORT_private_FROM (public);

  end = start + private->num_comments;
  for (p = start; p < end; p++)
    aiger_delete_str (private, *p);

  private->num_comments = 0;
  public->comments[0] = 0;

  return private->num_comments;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0xac(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x26d9
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x2710
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x26b1
movq -0x28(%rbp), %rax
movl $0x0, 0xac(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movl 0xac(%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_import_literal
static aiger_type *
aiger_import_literal (aiger_private * private, unsigned lit)
{
  unsigned var = aiger_lit2var (lit);
  EXPORT_public_FROM (private);

  if (var > public->maxvar)
    public->maxvar = var;

  while (var >= private->size_types)
    ENLARGE (private->types, private->size_types);

  return private->types + var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x2ac3
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x2ac5
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jb 0x2bdd
jmp 0x2ad7
movq -0x8(%rbp), %rax
movl 0x78(%rax), %eax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2af6
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x50(%rbp)
jmp 0x2b01
movl $0x1, %eax
movq %rax, -0x50(%rbp)
jmp 0x2b01
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x2b35
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x2b3d
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rsi
movq -0x40(%rbp), %rdx
callq 0x1140
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x2b9b
movq -0x48(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
subq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x70(%rcx), %rsi
movq -0x30(%rbp), %rdx
callq *%rax
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
jmp 0x2ac5
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movl -0x10(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_copy_str
static char *
aiger_copy_str (aiger_private * private, const char *str)
{
  char *res;

  if (!str || !str[0])
    return 0;

  NEWN (res, strlen (str) + 1);
  strcpy (res, str);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c20
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2c2a
movq $0x0, -0x8(%rbp)
jmp 0x2c85
jmp 0x2c2c
movq -0x18(%rbp), %rdi
callq 0x10b0
addq $0x1, %rax
shlq $0x0, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x28(%rbp), %rsi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1080
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_add_reset
void
aiger_add_reset (aiger * public, unsigned lit, unsigned reset) 
{
  IMPORT_private_FROM (public);
  aiger_type * type;
  assert (reset <= 1 || reset == lit);
  assert (!aiger_error (public));
  assert (lit);
  assert (!aiger_sign (lit));
  type = aiger_import_literal (private, lit);
  assert (type->latch);
  assert (type->idx < public->num_latches);
  public->latches[type->idx].reset = reset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x10(%rbp)
jbe 0x2fd8
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x2fda
jmp 0x2ff9
leaq 0x93e5(%rip), %rdi      # 0xc3c6
leaq 0x92c1(%rip), %rsi      # 0xc2a9
movl $0x1a4, %edx            # imm = 0x1A4
leaq 0x93ed(%rip), %rcx      # 0xc3e1
callq 0x10f0
movq -0x8(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x300a
jmp 0x3029
leaq 0x92e6(%rip), %rdi      # 0xc2f7
leaq 0x9291(%rip), %rsi      # 0xc2a9
movl $0x1a5, %edx            # imm = 0x1A5
leaq 0x93bd(%rip), %rcx      # 0xc3e1
callq 0x10f0
cmpl $0x0, -0xc(%rbp)
je 0x3031
jmp 0x3050
leaq 0x93a5(%rip), %rdi      # 0xc3dd
leaq 0x926a(%rip), %rsi      # 0xc2a9
movl $0x1a6, %edx            # imm = 0x1A6
leaq 0x9396(%rip), %rcx      # 0xc3e1
callq 0x10f0
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x305d
jmp 0x307c
leaq 0x92e3(%rip), %rdi      # 0xc347
leaq 0x923e(%rip), %rsi      # 0xc2a9
movl $0x1a7, %edx            # imm = 0x1A7
leaq 0x936a(%rip), %rcx      # 0xc3e1
callq 0x10f0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2a90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x30a0
jmp 0x30bf
leaq 0x9d6d(%rip), %rdi      # 0xce14
leaq 0x91fb(%rip), %rsi      # 0xc2a9
movl $0x1a9, %edx            # imm = 0x1A9
leaq 0x9327(%rip), %rcx      # 0xc3e1
callq 0x10f0
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x30d1
jmp 0x30f0
leaq 0x9343(%rip), %rdi      # 0xc41b
leaq 0x91ca(%rip), %rsi      # 0xc2a9
movl $0x1aa, %edx            # imm = 0x1AA
leaq 0x92f6(%rip), %rcx      # 0xc3e1
callq 0x10f0
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rdx
movl 0x4(%rdx), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_add_output
void
aiger_add_output (aiger * public, unsigned lit, const char *name)
{
  IMPORT_private_FROM (public);
  aiger_symbol symbol;
  aiger_import_literal (private, lit);
  CLR (symbol);
  symbol.lit = lit;
  symbol.name = aiger_copy_str (private, name);
  PUSH (public->outputs, public->num_outputs, private->size_outputs, symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2a90
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1100
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x94(%rcx), %eax
jne 0x3293
jmp 0x318a
movq -0x20(%rbp), %rax
movl 0x94(%rax), %eax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x31ac
movq -0x48(%rbp), %rax
shlq %rax
movq %rax, -0x78(%rbp)
jmp 0x31b7
movl $0x1, %eax
movq %rax, -0x78(%rbp)
jmp 0x31b7
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x31eb
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x31f3
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x60(%rbp), %rsi
callq *%rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x68(%rbp), %rdx
callq 0x1140
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x3251
movq -0x70(%rbp), %rdi
addq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
subq -0x58(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rsi
movq -0x58(%rbp), %rdx
callq *%rax
movq -0x70(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x94(%rax)
jmp 0x3293
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0xc(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rdx)
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_add_bad
void
aiger_add_bad (aiger * public, unsigned lit, const char *name)
{
  IMPORT_private_FROM (public);
  aiger_symbol symbol;
  aiger_import_literal (private, lit);
  CLR (symbol);
  symbol.lit = lit;
  symbol.name = aiger_copy_str (private, name);
  PUSH (public->bad, public->num_bad, private->size_bad, symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2a90
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1100
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x9c(%rcx), %eax
jne 0x3453
jmp 0x334a
movq -0x20(%rbp), %rax
movl 0x9c(%rax), %eax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x336c
movq -0x48(%rbp), %rax
shlq %rax
movq %rax, -0x78(%rbp)
jmp 0x3377
movl $0x1, %eax
movq %rax, -0x78(%rbp)
jmp 0x3377
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x33ab
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x33b3
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x60(%rbp), %rsi
callq *%rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x68(%rbp), %rdx
callq 0x1140
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x3411
movq -0x70(%rbp), %rdi
addq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
subq -0x58(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rsi
movq -0x58(%rbp), %rdx
callq *%rax
movq -0x70(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x9c(%rax)
jmp 0x3453
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x14(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x14(%rdx)
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_add_constraint
void
aiger_add_constraint (aiger * public, unsigned lit, const char *name)
{
  IMPORT_private_FROM (public);
  aiger_symbol symbol;
  aiger_import_literal (private, lit);
  CLR (symbol);
  symbol.lit = lit;
  symbol.name = aiger_copy_str (private, name);
  PUSH (public->constraints, 
        public->num_constraints, private->size_constraints, symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2a90
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1100
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0xa0(%rcx), %eax
jne 0x3613
jmp 0x350a
movq -0x20(%rbp), %rax
movl 0xa0(%rax), %eax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x352c
movq -0x48(%rbp), %rax
shlq %rax
movq %rax, -0x78(%rbp)
jmp 0x3537
movl $0x1, %eax
movq %rax, -0x78(%rbp)
jmp 0x3537
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x356b
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x3573
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x60(%rbp), %rsi
callq *%rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x68(%rbp), %rdx
callq 0x1140
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x35d1
movq -0x70(%rbp), %rdi
addq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
subq -0x58(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rsi
movq -0x58(%rbp), %rdx
callq *%rax
movq -0x70(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xa0(%rax)
jmp 0x3613
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x18(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x18(%rdx)
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_add_fairness
void
aiger_add_fairness (aiger * public, unsigned lit, const char *name)
{
  IMPORT_private_FROM (public);
  aiger_symbol symbol;
  aiger_import_literal (private, lit);
  CLR (symbol);
  symbol.lit = lit;
  symbol.name = aiger_copy_str (private, name);
  PUSH (public->fairness, 
        public->num_fairness, private->size_fairness, symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2a90
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1100
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0xa8(%rcx), %eax
jne 0x3a23
jmp 0x391a
movq -0x20(%rbp), %rax
movl 0xa8(%rax), %eax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x393c
movq -0x48(%rbp), %rax
shlq %rax
movq %rax, -0x78(%rbp)
jmp 0x3947
movl $0x1, %eax
movq %rax, -0x78(%rbp)
jmp 0x3947
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
shlq $0x5, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x397b
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x3983
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x60(%rbp), %rsi
callq *%rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x68(%rbp), %rdx
callq 0x1140
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
jbe 0x39e1
movq -0x70(%rbp), %rdi
addq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
subq -0x58(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rsi
movq -0x58(%rbp), %rdx
callq *%rax
movq -0x70(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xa8(%rax)
jmp 0x3a23
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x20(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x20(%rdx)
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_check
const char *
aiger_check (aiger * public)
{
  IMPORT_private_FROM (public);

  assert (!aiger_error (public));

  aiger_check_next_defined (private);
  aiger_check_outputs_defined (private);
  aiger_check_bad_defined (private);
  aiger_check_constraints_defined (private);
  aiger_check_justice_defined (private);
  aiger_check_fairness_defined (private);
  aiger_check_right_hand_sides_defined (private);
  aiger_check_for_cycles (private);

  return private->error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x3fe5
jmp 0x4004
leaq 0x830b(%rip), %rdi      # 0xc2f7
leaq 0x82b6(%rip), %rsi      # 0xc2a9
movl $0x37c, %edx            # imm = 0x37C
leaq 0x84fc(%rip), %rcx      # 0xc4fb
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x4060
movq -0x10(%rbp), %rdi
callq 0x4190
movq -0x10(%rbp), %rdi
callq 0x4250
movq -0x10(%rbp), %rdi
callq 0x4310
movq -0x10(%rbp), %rdi
callq 0x43d0
movq -0x10(%rbp), %rdi
callq 0x44f0
movq -0x10(%rbp), %rdi
callq 0x45b0
movq -0x10(%rbp), %rdi
callq 0x4660
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_check_next_defined
static void
aiger_check_next_defined (aiger_private * private)
{
  EXPORT_public_FROM (private);
  unsigned i, next, latch;
  aiger_symbol *symbol;

  if (private->error)
    return;

  for (i = 0; !private->error && i < public->num_latches; i++)
    {
      symbol = public->latches + i;
      latch = symbol->lit;
      next = symbol->next;

      assert (!aiger_sign (latch));
      assert (private->types[aiger_lit2var (latch)].latch);

      if (!aiger_literal_defined (private, next))
	aiger_error_uu (private,
			"next state function %u of latch %u undefined",
			next, latch);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4087
jmp 0x4188
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xd0(%rcx)
movb %al, -0x29(%rbp)
jne 0x40b1
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x40bd
jmp 0x4188
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x40f3
jmp 0x4112
leaq 0x8897(%rip), %rdi      # 0xc991
leaq 0x81a8(%rip), %rsi      # 0xc2a9
movl $0x295, %edx            # imm = 0x295
leaq 0x8898(%rip), %rcx      # 0xc9a5
callq 0x10f0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movl -0x1c(%rbp), %ecx
shrl %ecx
movl %ecx, %ecx
movb (%rax,%rcx,8), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4132
jmp 0x4151
leaq 0x889b(%rip), %rdi      # 0xc9d4
leaq 0x8169(%rip), %rsi      # 0xc2a9
movl $0x296, %edx            # imm = 0x296
leaq 0x8859(%rip), %rcx      # 0xc9a5
callq 0x10f0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x9f10
cmpl $0x0, %eax
jne 0x4178
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq 0x888d(%rip), %rsi      # 0xca00
callq 0x9fe0
jmp 0x417a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x408e
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_check_outputs_defined
static void
aiger_check_outputs_defined (aiger_private * private)
{
  EXPORT_public_FROM (private);
  unsigned i, output;

  if (private->error)
    return;

  for (i = 0; !private->error && i < public->num_outputs; i++)
    {
      output = public->outputs[i].lit;
      output = aiger_strip (output);
      if (output <= 1)
	continue;

      if (!aiger_literal_defined (private, output))
	aiger_error_u (private, "output %u undefined", output);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x41b7
jmp 0x4246
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xd0(%rcx)
movb %al, -0x19(%rbp)
jne 0x41e1
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x41ea
jmp 0x4246
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
ja 0x4212
jmp 0x4238
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x9f10
cmpl $0x0, %eax
jne 0x4236
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x889b(%rip), %rsi      # 0xcacc
callq 0xa150
jmp 0x4238
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41be
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_check_bad_defined
static void
aiger_check_bad_defined (aiger_private * private)
{
  EXPORT_public_FROM (private);
  unsigned i, bad;

  if (private->error)
    return;

  for (i = 0; !private->error && i < public->num_bad; i++)
    {
      bad = public->bad[i].lit;
      bad = aiger_strip (bad);
      if (bad <= 1)
	continue;

      if (!aiger_literal_defined (private, bad))
	aiger_error_u (private, "bad %u undefined", bad);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4277
jmp 0x4306
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xd0(%rcx)
movb %al, -0x19(%rbp)
jne 0x42a1
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x42aa
jmp 0x4306
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
ja 0x42d2
jmp 0x42f8
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x9f10
cmpl $0x0, %eax
jne 0x42f6
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x8836(%rip), %rsi      # 0xcb27
callq 0xa150
jmp 0x42f8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x427e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_check_constraints_defined
static void
aiger_check_constraints_defined (aiger_private * private)
{
  EXPORT_public_FROM (private);
  unsigned i, constraint;

  if (private->error)
    return;

  for (i = 0; !private->error && i < public->num_constraints; i++)
    {
      constraint = public->constraints[i].lit;
      constraint = aiger_strip (constraint);
      if (constraint <= 1)
	continue;

      if (!aiger_literal_defined (private, constraint))
	aiger_error_u (private, "constraint %u undefined", constraint);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4337
jmp 0x43c6
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xd0(%rcx)
movb %al, -0x19(%rbp)
jne 0x4361
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x436a
jmp 0x43c6
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
ja 0x4392
jmp 0x43b8
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x9f10
cmpl $0x0, %eax
jne 0x43b6
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x8787(%rip), %rsi      # 0xcb38
callq 0xa150
jmp 0x43b8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x433e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_check_justice_defined
static void
aiger_check_justice_defined (aiger_private * private) 
{
  EXPORT_public_FROM (private);
  unsigned i, j, justice;

  if (private->error)
    return;

  for (i = 0; !private->error && i < public->num_justice; i++)
    {
      for (j = 0; !private->error && j < public->justice[i].size; j++)
	{
	  justice = public->justice[i].lits[j];
	  justice = aiger_strip (justice);
	  if (justice <= 1)
	    continue;

	  if (!aiger_literal_defined (private, justice))
	    aiger_error_u (private, "justice %u undefined", justice);
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x43f7
jmp 0x44e2
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xd0(%rcx)
movb %al, -0x1d(%rbp)
jne 0x4421
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
setb %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x442d
jmp 0x44e2
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xd0(%rcx)
movb %al, -0x1e(%rbp)
jne 0x4465
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
movl -0x14(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
setb %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x446e
jmp 0x44d2
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
ja 0x449e
jmp 0x44c4
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x9f10
cmpl $0x0, %eax
jne 0x44c2
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x8693(%rip), %rsi      # 0xcb50
callq 0xa150
jmp 0x44c4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4434
jmp 0x44d4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x43fe
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_check_fairness_defined
static void
aiger_check_fairness_defined (aiger_private * private)
{
  EXPORT_public_FROM (private);
  unsigned i, fairness;

  if (private->error)
    return;

  for (i = 0; !private->error && i < public->num_fairness; i++)
    {
      fairness = public->fairness[i].lit;
      fairness = aiger_strip (fairness);
      if (fairness <= 1)
	continue;

      if (!aiger_literal_defined (private, fairness))
	aiger_error_u (private, "fairness %u undefined", fairness);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4517
jmp 0x45a6
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xd0(%rcx)
movb %al, -0x19(%rbp)
jne 0x4541
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x454a
jmp 0x45a6
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
ja 0x4572
jmp 0x4598
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x9f10
cmpl $0x0, %eax
jne 0x4596
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x85d4(%rip), %rsi      # 0xcb65
callq 0xa150
jmp 0x4598
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x451e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_check_right_hand_sides_defined
static void
aiger_check_right_hand_sides_defined (aiger_private * private)
{
  EXPORT_public_FROM (private);
  aiger_and *and;
  unsigned i;

  if (private->error)
    return;

  for (i = 0; !private->error && i < public->num_ands; i++)
    {
      and = public->ands + i;
      aiger_check_right_hand_side_defined (private, and, and->rhs0);
      aiger_check_right_hand_side_defined (private, and, and->rhs1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x45d4
jmp 0x4650
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0xd0(%rcx)
movb %al, -0x1d(%rbp)
jne 0x45fe
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
setb %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x4607
jmp 0x4650
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
callq 0xa2b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0xa2b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x45db
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_write_symbols
static int
aiger_write_symbols (aiger * public, void *state, aiger_put put)
{
  if (!aiger_write_symbols_aux (public, state, put,
				"i", public->inputs, public->num_inputs))
    return 0;

  if (!aiger_write_symbols_aux (public, state, put,
				"l", public->latches, public->num_latches))
    return 0;

  if (!aiger_write_symbols_aux (public, state, put,
				"o", public->outputs, public->num_outputs))
    return 0;

  if (!aiger_write_symbols_aux (public, state, put,
				"b", public->bad, public->num_bad))
    return 0;

  if (!aiger_write_symbols_aux (public, state, put,
				"c", public->constraints,
				public->num_constraints))
    return 0;

  if (!aiger_write_symbols_aux (public, state, put,
				"j", public->justice, public->num_justice))
    return 0;

  if (!aiger_write_symbols_aux (public, state, put,
				"f", public->fairness, public->num_fairness))
    return 0;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x4(%rax), %r9d
leaq 0x7cce(%rip), %rcx      # 0xcc85
callq 0xa330
cmpl $0x0, %eax
jne 0x4fcd
movl $0x0, -0x4(%rbp)
jmp 0x5121
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x8(%rax), %r9d
leaq 0x820f(%rip), %rcx      # 0xd1ff
callq 0xa330
cmpl $0x0, %eax
jne 0x5006
movl $0x0, -0x4(%rbp)
jmp 0x5121
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %r8
movq -0x10(%rbp), %rax
movl 0xc(%rax), %r9d
leaq 0x7c5e(%rip), %rcx      # 0xcc87
callq 0xa330
cmpl $0x0, %eax
jne 0x503f
movl $0x0, -0x4(%rbp)
jmp 0x5121
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x14(%rax), %r9d
leaq 0x783a(%rip), %rcx      # 0xc89c
callq 0xa330
cmpl $0x0, %eax
jne 0x5078
movl $0x0, -0x4(%rbp)
jmp 0x5121
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x18(%rax), %r9d
leaq 0x7099(%rip), %rcx      # 0xc134
callq 0xa330
cmpl $0x0, %eax
jne 0x50ae
movl $0x0, -0x4(%rbp)
jmp 0x5121
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %r9d
leaq 0x7b99(%rip), %rcx      # 0xcc6a
callq 0xa330
cmpl $0x0, %eax
jne 0x50e4
movl $0x0, -0x4(%rbp)
jmp 0x5121
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %r8
movq -0x10(%rbp), %rax
movl 0x20(%rax), %r9d
leaq 0x7b82(%rip), %rcx      # 0xcc89
callq 0xa330
cmpl $0x0, %eax
jne 0x511a
movl $0x0, -0x4(%rbp)
jmp 0x5121
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_write_comments
static int
aiger_write_comments (aiger * public, void *state, aiger_put put)
{
  char **p, *str;

  for (p = public->comments; (str = *p); p++)
    {
      if (aiger_put_s (state, put, str) == EOF)
	return 0;

      if (put ('\n', state) == EOF)
	return 0;
    }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x523d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7380
cmpl $-0x1, %eax
jne 0x5210
movl $0x0, -0x4(%rbp)
jmp 0x5244
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq *%rax
cmpl $-0x1, %eax
jne 0x522d
movl $0x0, -0x4(%rbp)
jmp 0x5244
jmp 0x522f
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x51e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_is_reencoded
int
aiger_is_reencoded (aiger * public)
{
  unsigned i, tmp, max, lhs;
  aiger_and *and;

  max = 0;
  for (i = 0; i < public->num_inputs; i++)
    {
      max += 2;
      tmp = public->inputs[i].lit;
      if (max != tmp)
	return 0;
    }

  for (i = 0; i < public->num_latches; i++)
    {
      max += 2;
      tmp = public->latches[i].lit;
      if (max != tmp)
	return 0;
    }

  lhs = aiger_max_input_or_latch (public) + 2;
  for (i = 0; i < public->num_ands; i++)
    {
      and = public->ands + i;

      if (and->lhs <= max)
	return 0;

      if (and->lhs != lhs)
	return 0;

      if (and->lhs < and->rhs0)
	return 0;

      if (and->rhs0 < and->rhs1)
	return 0;

      lhs += 2;
    }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x52b7
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x52aa
movl $0x0, -0x4(%rbp)
jmp 0x53be
jmp 0x52ac
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x526a
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x530b
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x52fe
movl $0x0, -0x4(%rbp)
jmp 0x53be
jmp 0x5300
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52be
movq -0x10(%rbp), %rdi
callq 0x53d0
addl $0x2, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x53b7
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
ja 0x535b
movl $0x0, -0x4(%rbp)
jmp 0x53be
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x20(%rbp), %eax
je 0x536f
movl $0x0, -0x4(%rbp)
jmp 0x53be
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x5387
movl $0x0, -0x4(%rbp)
jmp 0x53be
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x53a0
movl $0x0, -0x4(%rbp)
jmp 0x53be
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5321
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_max_input_or_latch
static unsigned
aiger_max_input_or_latch (aiger * public)
{
  unsigned i, tmp, res;

  res = 0;

  for (i = 0; i < public->num_inputs; i++)
    {
      tmp = public->inputs[i].lit;
      assert (!aiger_sign (tmp));
      if (tmp > res)
	res = tmp;
    }

  for (i = 0; i < public->num_latches; i++)
    {
      tmp = public->latches[i].lit;
      assert (!aiger_sign (tmp));
      if (tmp > res)
	res = tmp;
    }

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x5454
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x541a
jmp 0x5439
leaq 0x78e1(%rip), %rdi      # 0xcd02
leaq 0x6e81(%rip), %rsi      # 0xc2a9
movl $0x50b, %edx            # imm = 0x50B
leaq 0x78e0(%rip), %rcx      # 0xcd14
callq 0x10f0
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x5447
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5449
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x53ea
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x54c5
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x548b
jmp 0x54aa
leaq 0x7870(%rip), %rdi      # 0xcd02
leaq 0x6e10(%rip), %rsi      # 0xc2a9
movl $0x513, %edx            # imm = 0x513
leaq 0x786f(%rip), %rcx      # 0xcd14
callq 0x10f0
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x54b8
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x54ba
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x545b
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_coi
const unsigned char *
aiger_coi (aiger * public)
{
  IMPORT_private_FROM (public);
  private->size_coi = public->maxvar + 1;
  NEWN (private->coi, private->size_coi);
  memset (private->coi, 1, private->size_coi);
  return private->coi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x88(%rax)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
shlq $0x0, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
movl %eax, %edx
movl $0x1, %esi
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_strip_symbols_and_comments
unsigned
aiger_strip_symbols_and_comments (aiger * public)
{
  IMPORT_private_FROM (public);
  unsigned res;

  assert (!aiger_error (public));

  res = aiger_delete_comments (public);

  res += aiger_delete_symbols_aux (private,
				   public->inputs,
				   private->size_inputs);
  res += aiger_delete_symbols_aux (private,
				   public->latches,
				   private->size_latches);
  res += aiger_delete_symbols_aux (private,
				   public->outputs,
				   private->size_outputs);
  res += aiger_delete_symbols_aux (private,
				   public->bad, 
				   private->size_bad);
  res += aiger_delete_symbols_aux (private,
				   public->constraints,
				   private->size_constraints);
  res += aiger_delete_symbols_aux (private,
				   public->justice,
				   private->size_justice);
  res += aiger_delete_symbols_aux (private,
				   public->fairness,
				   private->size_fairness);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x6c55
jmp 0x6c74
leaq 0x569b(%rip), %rdi      # 0xc2f7
leaq 0x5646(%rip), %rsi      # 0xc2a9
movl $0x6bb, %edx            # imm = 0x6BB
leaq 0x5a0f(%rip), %rcx      # 0xc67e
callq 0x10f0
movq -0x8(%rbp), %rdi
callq 0x2670
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %edx
callq 0x6d70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x90(%rax), %edx
callq 0x6d70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x94(%rax), %edx
callq 0x6d70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x9c(%rax), %edx
callq 0x6d70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xa0(%rax), %edx
callq 0x6d70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xa4(%rax), %edx
callq 0x6d70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %edx
callq 0x6d70
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_delete_symbols_aux
static unsigned
aiger_delete_symbols_aux (aiger_private * private,
			  aiger_symbol * symbols, unsigned size)
{
  unsigned i, res;

  res = 0;
  for (i = 0; i < size; i++)
    {
      aiger_symbol *s = symbols + i;
      if (!s->name)
	continue;

      aiger_delete_str (private, s->name);
      s->name = 0;
      res++;
    }

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x6de9
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x6db8
jmp 0x6dde
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2710
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6d91
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)