LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_write_generic
int
aiger_write_generic (aiger * public,
		     aiger_mode mode, void *state, aiger_put put)
{
  assert (!aiger_error (public));

  if ((mode & aiger_ascii_mode))
    {
      if (!aiger_write_ascii (public, state, put))
	return 0;
    }
  else
    {
      if (!aiger_write_binary (public, state, put))
	return 0;
    }

  if (!(mode & aiger_stripped_mode))
    {
      if (aiger_have_at_least_one_symbol (public))
	{
	  if (!aiger_write_symbols (public, state, put))
	    return 0;
	}

      if (public->comments[0])
	{
	  if (aiger_put_s (state, put, "c\n") == EOF)
	    return 0;

	  if (!aiger_write_comments (public, state, put))
	    return 0;
	}
    }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x6e28
jmp 0x6e47
leaq 0x54c8(%rip), %rdi      # 0xc2f7
leaq 0x5473(%rip), %rsi      # 0xc2a9
movl $0x6db, %edx            # imm = 0x6DB
leaq 0x5873(%rip), %rcx      # 0xc6b5
callq 0x10f0
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6e76
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6f40
cmpl $0x0, %eax
jne 0x6e74
movl $0x0, -0x4(%rbp)
jmp 0x6f32
jmp 0x6e9a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7090
cmpl $0x0, %eax
jne 0x6e98
movl $0x0, -0x4(%rbp)
jmp 0x6f32
jmp 0x6e9a
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x6f2b
movq -0x10(%rbp), %rdi
callq 0x7250
cmpl $0x0, %eax
je 0x6ed8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4f80
cmpl $0x0, %eax
jne 0x6ed6
movl $0x0, -0x4(%rbp)
jmp 0x6f32
jmp 0x6ed8
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
cmpq $0x0, (%rax)
je 0x6f29
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x5800(%rip), %rdx      # 0xc6f5
callq 0x7380
cmpl $-0x1, %eax
jne 0x6f08
movl $0x0, -0x4(%rbp)
jmp 0x6f32
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x51c0
cmpl $0x0, %eax
jne 0x6f27
movl $0x0, -0x4(%rbp)
jmp 0x6f32
jmp 0x6f29
jmp 0x6f2b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %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_write_ascii
static int
aiger_write_ascii (aiger * public, void *state, aiger_put put)
{
  aiger_and *and;
  unsigned i;

  assert (!aiger_check (public));

  if (!aiger_write_header (public, "aag", 0, state, put))
    return 0;

  for (i = 0; i < public->num_ands; i++)
    {
      and = public->ands + i;
      if (aiger_put_u (state, put, and->lhs) == EOF ||
	  put (' ', state) == EOF ||
	  aiger_put_u (state, put, and->rhs0) == EOF ||
	  put (' ', state) == EOF ||
	  aiger_put_u (state, put, and->rhs1) == EOF ||
	  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), %rdi
callq 0x3fc0
cmpq $0x0, %rax
jne 0x6f65
jmp 0x6f84
leaq 0x56fc(%rip), %rdi      # 0xc668
leaq 0x5336(%rip), %rsi      # 0xc2a9
movl $0x4ed, %edx            # imm = 0x4ED
leaq 0x5ef9(%rip), %rcx      # 0xce78
callq 0x10f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x5831(%rip), %rsi      # 0xc7c8
xorl %edx, %edx
callq 0xa530
cmpl $0x0, %eax
jne 0x6faf
movl $0x0, -0x4(%rbp)
jmp 0x7082
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x707b
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl -0x2c(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movl (%rax), %edx
callq 0xa460
cmpl $-0x1, %eax
je 0x7062
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rsi
movl $0x20, %edi
callq *%rax
cmpl $-0x1, %eax
je 0x7062
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
callq 0xa460
cmpl $-0x1, %eax
je 0x7062
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rsi
movl $0x20, %edi
callq *%rax
cmpl $-0x1, %eax
je 0x7062
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edx
callq 0xa460
cmpl $-0x1, %eax
je 0x7062
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq *%rax
cmpl $-0x1, %eax
jne 0x706b
movl $0x0, -0x4(%rbp)
jmp 0x7082
jmp 0x706d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6fb6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %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_write_binary
static int
aiger_write_binary (aiger * public, void *state, aiger_put put)
{
  aiger_and *and;
  unsigned lhs, i;

  assert (!aiger_check (public));

  aiger_reencode (public);

  if (!aiger_write_header (public, "aig", 1, state, put))
    return 0;

  lhs = aiger_max_input_or_latch (public) + 2;

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

      assert (lhs == and->lhs);
      assert (lhs > and->rhs0);
      assert (and->rhs0 >= and->rhs1);

      if (!aiger_write_delta (state, put, lhs - and->rhs0))
	return 0;

      if (!aiger_write_delta (state, put, and->rhs0 - and->rhs1))
	return 0;

      lhs += 2;
    }

  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), %rdi
callq 0x3fc0
cmpq $0x0, %rax
jne 0x70b5
jmp 0x70d4
leaq 0x55ac(%rip), %rdi      # 0xc668
leaq 0x51e6(%rip), %rsi      # 0xc2a9
movl $0x698, %edx            # imm = 0x698
leaq 0x5ddb(%rip), %rcx      # 0xceaa
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x54d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x5ded(%rip), %rsi      # 0xcedd
movl $0x1, %edx
callq 0xa530
cmpl $0x0, %eax
jne 0x710b
movl $0x0, -0x4(%rbp)
jmp 0x723d
movq -0x10(%rbp), %rdi
callq 0x53d0
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x7236
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movl -0x30(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x7154
jmp 0x7173
leaq 0x5d86(%rip), %rdi      # 0xcee1
leaq 0x5147(%rip), %rsi      # 0xc2a9
movl $0x6a5, %edx            # imm = 0x6A5
leaq 0x5d3c(%rip), %rcx      # 0xceaa
callq 0x10f0
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jbe 0x7181
jmp 0x71a0
leaq 0x5d69(%rip), %rdi      # 0xcef1
leaq 0x511a(%rip), %rsi      # 0xc2a9
movl $0x6a6, %edx            # imm = 0x6A6
leaq 0x5d0f(%rip), %rcx      # 0xceaa
callq 0x10f0
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x71b2
jmp 0x71d1
leaq 0x5d48(%rip), %rdi      # 0xcf01
leaq 0x50e9(%rip), %rsi      # 0xc2a9
movl $0x6a7, %edx            # imm = 0x6A7
leaq 0x5cde(%rip), %rcx      # 0xceaa
callq 0x10f0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x28(%rbp), %rax
subl 0x4(%rax), %edx
callq 0xad40
cmpl $0x0, %eax
jne 0x71f6
movl $0x0, -0x4(%rbp)
jmp 0x723d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x28(%rbp), %rax
subl 0x8(%rax), %edx
callq 0xad40
cmpl $0x0, %eax
jne 0x721f
movl $0x0, -0x4(%rbp)
jmp 0x723d
movl -0x2c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7121
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %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_have_at_least_one_symbol
static int
aiger_have_at_least_one_symbol (aiger * public)
{
  if (aiger_have_at_least_one_symbol_aux (public,
					  public->inputs, public->num_inputs))
    return 1;

  if (aiger_have_at_least_one_symbol_aux (public,
					  public->outputs,
					  public->num_outputs))
    return 1;

  if (aiger_have_at_least_one_symbol_aux (public,
					  public->latches,
					  public->num_latches))
    return 1;

  if (aiger_have_at_least_one_symbol_aux (public,
					  public->bad,
					  public->num_bad))
    return 1;

  if (aiger_have_at_least_one_symbol_aux (public,
					  public->constraints,
					  public->num_constraints))
    return 1;

  if (aiger_have_at_least_one_symbol_aux (public,
					  public->justice,
					  public->num_justice))
    return 1;

  if (aiger_have_at_least_one_symbol_aux (public,
					  public->fairness,
					  public->num_fairness))
    return 1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
callq 0xadd0
cmpl $0x0, %eax
je 0x7285
movl $0x1, -0x4(%rbp)
jmp 0x7376
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
callq 0xadd0
cmpl $0x0, %eax
je 0x72ae
movl $0x1, -0x4(%rbp)
jmp 0x7376
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
callq 0xadd0
cmpl $0x0, %eax
je 0x72d7
movl $0x1, -0x4(%rbp)
jmp 0x7376
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
callq 0xadd0
cmpl $0x0, %eax
je 0x72fd
movl $0x1, -0x4(%rbp)
jmp 0x7376
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0xadd0
cmpl $0x0, %eax
je 0x7323
movl $0x1, -0x4(%rbp)
jmp 0x7376
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edx
callq 0xadd0
cmpl $0x0, %eax
je 0x7349
movl $0x1, -0x4(%rbp)
jmp 0x7376
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
callq 0xadd0
cmpl $0x0, %eax
je 0x736f
movl $0x1, -0x4(%rbp)
jmp 0x7376
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_put_s
static int
aiger_put_s (void *state, aiger_put put, const char *str)
{
  const char *p;
  char ch;

  for (p = str; (ch = *p); p++)
    if (put (ch, state) == EOF)
      return EOF;

  return p - str;		/* 'fputs' semantics, >= 0 is OK */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x29(%rbp)
cmpb $0x0, %al
je 0x73d7
movq -0x18(%rbp), %rax
movb -0x29(%rbp), %cl
movq -0x10(%rbp), %rsi
movsbl %cl, %edi
callq *%rax
cmpl $-0x1, %eax
jne 0x73c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x73e5
jmp 0x73c9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x739c
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_write_to_string
int
aiger_write_to_string (aiger * public, aiger_mode mode, char *str, size_t len)
{
  aiger_buffer buffer;
  int res;

  assert (!aiger_error (public));

  buffer.start = str;
  buffer.cursor = str;
  buffer.end = str + len;
  res = aiger_write_generic (public,
			     mode, &buffer, (aiger_put) aiger_string_put);

  if (!res)
    return 0;

  if (aiger_string_put (0, &buffer) == EOF)
    return 0;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x7478
jmp 0x7497
leaq 0x4e78(%rip), %rdi      # 0xc2f7
leaq 0x4e23(%rip), %rsi      # 0xc2a9
movl $0x70b, %edx            # imm = 0x70B
leaq 0x529b(%rip), %rcx      # 0xc72d
callq 0x10f0
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x40(%rbp), %rdx
leaq 0x4b(%rip), %rcx        # 0x7510
callq 0x6e00
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jne 0x74dc
movl $0x0, -0x4(%rbp)
jmp 0x74fc
xorl %edi, %edi
leaq -0x40(%rbp), %rsi
callq 0x7510
cmpl $-0x1, %eax
jne 0x74f5
movl $0x0, -0x4(%rbp)
jmp 0x74fc
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %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_string_put
static int
aiger_string_put (char ch, aiger_buffer * buffer)
{
  unsigned char res;
  if (buffer->cursor == buffer->end)
    return EOF;
  *buffer->cursor++ = ch;
  res = ch;
  return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x7539
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x755e
movb -0x5(%rbp), %cl
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb %cl, (%rax)
movb -0x5(%rbp), %al
movb %al, -0x11(%rbp)
movsbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_read_generic
const char *
aiger_read_generic (aiger * public, void *state, aiger_get get)
{
  IMPORT_private_FROM (public);
  aiger_reader reader;
  const char *error;

  assert (!aiger_error (public));

  CLR (reader);

  reader.lineno = 1;
  reader.state = state;
  reader.get = get;
  reader.ch = ' ';

  error = aiger_read_header (public, &reader);
  if (error)
    return error;

  if (reader.mode == aiger_ascii_mode)
    error = aiger_read_ascii (public, &reader);
  else
    error = aiger_read_binary (public, &reader);

  if (error)
    return error;

  error = aiger_read_symbols_and_comments (public, &reader);

  DELETEN (reader.buffer, reader.size_buffer);

  if (error)
    return error;

  return aiger_check (public);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x7830
jmp 0x784f
leaq 0x4ac0(%rip), %rdi      # 0xc2f7
leaq 0x4a6b(%rip), %rsi      # 0xc2a9
movl $0x9ee, %edx            # imm = 0x9EE
leaq 0x4f8a(%rip), %rcx      # 0xc7d4
callq 0x10f0
jmp 0x7851
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x1100
movl $0x1, -0x74(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x20, -0x78(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x7990
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x78b6
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7977
cmpl $0x1, -0x60(%rbp)
jne 0x78d5
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x9010
movq %rax, -0x90(%rbp)
jmp 0x78ec
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x91d0
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x7903
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7977
movq -0x10(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x92f0
movq %rax, -0x90(%rbp)
movl -0x2c(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x98(%rbp)
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x38(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq *%rax
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x796a
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7977
movq -0x10(%rbp), %rdi
callq 0x3fc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %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_read_binary
static const char *
aiger_read_binary (aiger * public, aiger_reader * reader)
{
  unsigned i, lhs, rhs0, rhs1, delta, charno;
  IMPORT_private_FROM (public);
  const char *error;

  delta = 0;			/* avoid warning with -O3 */

  lhs = aiger_max_input_or_latch (public);

  for (i = 0; i < reader->ands; i++)
    {
      lhs += 2;
      charno = reader->charno;
      error = aiger_read_delta (private, reader, &delta);
      if (error)
	return error;

      if (delta > lhs)		/* can at most be the same */
      INVALID_DELTA:
	return aiger_error_u (private, "character %u: invalid delta", charno);

      rhs0 = lhs - delta;

      charno = reader->charno;
      error = aiger_read_delta (private, reader, &delta);
      if (error)
	return error;

      if (delta > rhs0)		/* can well be the same ! */
	goto INVALID_DELTA;

      rhs1 = rhs0 - delta;

      aiger_add_and (public, lhs, rhs0, rhs1);
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x53d0
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jae 0x92dd
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0xb2c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x924e
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x92e5
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jbe 0x9271
jmp 0x9258
movq -0x38(%rbp), %rdi
movl -0x30(%rbp), %edx
leaq 0x4165(%rip), %rsi      # 0xd3cb
callq 0xa150
movq %rax, -0x8(%rbp)
jmp 0x92e5
movl -0x20(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0xb2c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x92aa
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x92e5
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jbe 0x92b4
jmp 0x9258
movl -0x24(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x3a70
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9202
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_open_and_read_from_file
const char *
aiger_open_and_read_from_file (aiger * public, const char *file_name)
{
  IMPORT_private_FROM (public);
  char *cmd, size_cmd;
  const char *res;
  int pclose_file;
  FILE *file;

  assert (!aiger_error (public));

  if (aiger_has_suffix (file_name, ".gz"))
    {
      size_cmd = strlen (file_name) + strlen (GUNZIP);
      NEWN (cmd, size_cmd);
      sprintf (cmd, GUNZIP, file_name);
      file = popen (cmd, "r");
      DELETEN (cmd, size_cmd);
      pclose_file = 1;
    }
  else
    {
      file = fopen (file_name, "rb");
      pclose_file = 0;
    }

  if (!file)
    return aiger_error_s (private, "can not read '%s'", file_name);

  res = aiger_read_from_file (public, file);

  if (pclose_file)
    pclose (file);
  else
    fclose (file);

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x97d9
jmp 0x97f8
leaq 0x2b17(%rip), %rdi      # 0xc2f7
leaq 0x2ac2(%rip), %rsi      # 0xc2a9
movl $0xa1d, %edx            # imm = 0xA1D
leaq 0x304e(%rip), %rcx      # 0xc841
callq 0x10f0
movq -0x18(%rbp), %rdi
leaq 0x2fcd(%rip), %rsi      # 0xc7d0
callq 0x7760
cmpl $0x0, %eax
je 0x98c5
movq -0x18(%rbp), %rdi
callq 0x10b0
addq $0x18, %rax
movb %al, -0x29(%rbp)
movsbq -0x29(%rbp), %rax
shlq $0x0, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x50(%rbp), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3016(%rip), %rsi      # 0xc882
movb $0x0, %al
callq 0x1180
movq -0x28(%rbp), %rdi
leaq 0x3551(%rip), %rsi      # 0xcdcf
callq 0x1160
movq %rax, -0x48(%rbp)
movsbq -0x29(%rbp), %rax
shlq $0x0, %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x28(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq *%rax
movq $0x0, -0x28(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x98e0
movq -0x18(%rbp), %rdi
leaq 0x2fcb(%rip), %rsi      # 0xc89b
callq 0x1170
movq %rax, -0x48(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x9901
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2fa8(%rip), %rsi      # 0xc89e
callq 0x9940
movq %rax, -0x8(%rbp)
jmp 0x9934
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x9730
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x9923
movq -0x48(%rbp), %rdi
callq 0x10e0
jmp 0x992c
movq -0x48(%rbp), %rdi
callq 0x10a0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_error_s
static const char *
aiger_error_s (aiger_private * private, const char *s, const char *a)
{
  unsigned tmp_len, error_len;
  char *tmp;
  assert (!private->error);
  tmp_len = strlen (s) + strlen (a) + 1;
  NEWN (tmp, tmp_len);
  sprintf (tmp, s, a);
  error_len = strlen (tmp) + 1;
  NEWN (private->error, error_len);
  memcpy (private->error, tmp, error_len);
  DELETEN (tmp, tmp_len);
  return private->error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0x9964
jmp 0x9983
leaq 0x30fb(%rip), %rdi      # 0xca66
leaq 0x2937(%rip), %rsi      # 0xc2a9
movl $0x22f, %edx            # imm = 0x22F
leaq 0x3ccb(%rip), %rcx      # 0xd649
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x10b0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x1180
movq -0x28(%rbp), %rdi
callq 0x10b0
addq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x38(%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, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
movq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x1140
movl -0x1c(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq *%rax
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/reactive-systems[P]aiger-ltl-model-checker/aiger.c
// Function: aiger_get_symbol
const char *
aiger_get_symbol (aiger * public, unsigned lit)
{
  IMPORT_private_FROM (public);
  aiger_symbol *symbol;
  aiger_type *type;
  unsigned var;

  assert (!aiger_error (public));

  assert (lit);
  assert (!aiger_sign (lit));

  var = aiger_lit2var (lit);
  assert (var <= public->maxvar);
  type = private->types + var;

  if (type->input)
    symbol = public->inputs;
  else if (type->latch)
    symbol = public->latches;
  else
    return 0;

  return symbol[type->idx].name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x9ad8
jmp 0x9af7
leaq 0x2818(%rip), %rdi      # 0xc2f7
leaq 0x27c3(%rip), %rsi      # 0xc2a9
movl $0xa43, %edx            # imm = 0xA43
leaq 0x2dbe(%rip), %rcx      # 0xc8b0
callq 0x10f0
cmpl $0x0, -0x14(%rbp)
je 0x9aff
jmp 0x9b1e
leaq 0x28d7(%rip), %rdi      # 0xc3dd
leaq 0x279c(%rip), %rsi      # 0xc2a9
movl $0xa45, %edx            # imm = 0xA45
leaq 0x2d97(%rip), %rcx      # 0xc8b0
callq 0x10f0
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x9b2b
jmp 0x9b4a
leaq 0x2815(%rip), %rdi      # 0xc347
leaq 0x2770(%rip), %rsi      # 0xc2a9
movl $0xa46, %edx            # imm = 0xA46
leaq 0x2d6b(%rip), %rcx      # 0xc8b0
callq 0x10f0
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
ja 0x9b5f
jmp 0x9b7e
leaq 0x2d7e(%rip), %rdi      # 0xc8e4
leaq 0x273c(%rip), %rsi      # 0xc2a9
movl $0xa49, %edx            # imm = 0xA49
leaq 0x2d37(%rip), %rcx      # 0xc8b0
callq 0x10f0
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movl -0x34(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9bb2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9bde
movq -0x30(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9bd2
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9bdc
movq $0x0, -0x8(%rbp)
jmp 0x9bf8
jmp 0x9bde
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl 0x4(%rcx), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %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_lit2tag
int
aiger_lit2tag (aiger * public, unsigned lit) 
{
  aiger_type * type;
  lit = aiger_strip (lit);
  if (!lit) return 0;
  type = aiger_lit2type (public, lit);
  if (type->input) return 1;
  if (type->latch) return 2;
  return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x9c37
movl $0x0, -0x4(%rbp)
jmp 0x9c82
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9c90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9c60
movl $0x1, -0x4(%rbp)
jmp 0x9c82
movq -0x20(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9c7b
movl $0x2, -0x4(%rbp)
jmp 0x9c82
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_lit2type
static aiger_type *
aiger_lit2type (aiger * public, unsigned lit)
{
  IMPORT_private_FROM (public);
  aiger_type *type;
  unsigned var;

  assert (!aiger_sign (lit));
  var = aiger_lit2var (lit);
  assert (var <= public->maxvar);
  type = private->types + var;

  return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x9cb4
jmp 0x9cd3
leaq 0x268c(%rip), %rdi      # 0xc347
leaq 0x25e7(%rip), %rsi      # 0xc2a9
movl $0xa5d, %edx            # imm = 0xA5D
leaq 0x39c2(%rip), %rcx      # 0xd690
callq 0x10f0
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
ja 0x9ce8
jmp 0x9d07
leaq 0x2bf5(%rip), %rdi      # 0xc8e4
leaq 0x25b3(%rip), %rsi      # 0xc2a9
movl $0xa5f, %edx            # imm = 0xA5F
leaq 0x398e(%rip), %rcx      # 0xd690
callq 0x10f0
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movl -0x24(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
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_is_input
aiger_symbol *
aiger_is_input (aiger * public, unsigned lit)
{
  aiger_type *type;
  aiger_symbol *res;

  assert (!aiger_error (public));
  type = aiger_lit2type (public, lit);
  if (!type->input)
    return 0;

  res = public->inputs + type->idx;

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x9d50
jmp 0x9d6f
leaq 0x25a0(%rip), %rdi      # 0xc2f7
leaq 0x254b(%rip), %rsi      # 0xc2a9
movl $0xa77, %edx            # imm = 0xA77
leaq 0x2b90(%rip), %rcx      # 0xc8fa
callq 0x10f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9c90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9d99
movq $0x0, -0x8(%rbp)
jmp 0x9dbb
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_is_latch
aiger_symbol *
aiger_is_latch (aiger * public, unsigned lit)
{
  aiger_symbol *res;
  aiger_type *type;

  assert (!aiger_error (public));
  type = aiger_lit2type (public, lit);
  if (!type->latch)
    return 0;

  res = public->latches + type->idx;

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x9df0
jmp 0x9e0f
leaq 0x2500(%rip), %rdi      # 0xc2f7
leaq 0x24ab(%rip), %rsi      # 0xc2a9
movl $0xa87, %edx            # imm = 0xA87
leaq 0x2b24(%rip), %rcx      # 0xc92e
callq 0x10f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9c90
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9e3b
movq $0x0, -0x8(%rbp)
jmp 0x9e5d
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x28(%rbp), %rcx
movl 0x4(%rcx), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_is_and
aiger_and *
aiger_is_and (aiger * public, unsigned lit)
{
  aiger_type *type;
  aiger_and *res;

  assert (!aiger_error (public));
  type = aiger_lit2type (public, lit);
  if (!type->and)
    return 0;

  res = public->ands + type->idx;

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpq $0x0, %rax
jne 0x9e90
jmp 0x9eaf
leaq 0x2460(%rip), %rdi      # 0xc2f7
leaq 0x240b(%rip), %rsi      # 0xc2a9
movl $0xa97, %edx            # imm = 0xA97
leaq 0x2ab8(%rip), %rcx      # 0xc962
callq 0x10f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9c90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9edc
movq $0x0, -0x8(%rbp)
jmp 0x9efe
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %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_literal_defined
static int
aiger_literal_defined (aiger_private * private, unsigned lit)
{
  unsigned var = aiger_lit2var (lit);
#ifndef NDEBUG
  EXPORT_public_FROM (private);
#endif
  aiger_type *type;

  assert (var <= public->maxvar);
  if (!var)
    return 1;

  type = private->types + var;

  return type->and || type->input || type->latch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
ja 0x9f3c
jmp 0x9f5b
leaq 0x29a1(%rip), %rdi      # 0xc8e4
leaq 0x235f(%rip), %rsi      # 0xc2a9
movl $0x27c, %edx            # imm = 0x27C
leaq 0x2ad7(%rip), %rcx      # 0xca2d
callq 0x10f0
cmpl $0x0, -0x18(%rbp)
jne 0x9f6a
movl $0x1, -0x4(%rbp)
jmp 0x9fce
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movl -0x18(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0x9fc3
movq -0x28(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0x9fc3
movq -0x28(%rbp), %rax
movb (%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -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_error_uu
static const char *
aiger_error_uu (aiger_private * private, const char *s, unsigned a,
		unsigned b)
{
  unsigned tmp_len, error_len;
  char *tmp;
  assert (!private->error);
  tmp_len = strlen (s) + sizeof (a) * 4 + sizeof (b) * 4 + 1;
  NEWN (tmp, tmp_len);
  sprintf (tmp, s, a, b);
  error_len = strlen (tmp) + 1;
  NEWN (private->error, error_len);
  memcpy (private->error, tmp, error_len);
  DELETEN (tmp, tmp_len);
  return private->error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0xa006
jmp 0xa025
leaq 0x2a59(%rip), %rdi      # 0xca66
leaq 0x2295(%rip), %rsi      # 0xc2a9
movl $0x250, %edx            # imm = 0x250
leaq 0x2a56(%rip), %rcx      # 0xca76
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x10b0
addq $0x10, %rax
addq $0x10, %rax
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movb $0x0, %al
callq 0x1180
movq -0x28(%rbp), %rdi
callq 0x10b0
addq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x38(%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, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
movq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x1140
movl -0x1c(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq *%rax
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
addq $0x40, %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_error_u
static const char *
aiger_error_u (aiger_private * private, const char *s, unsigned u)
{
  unsigned tmp_len, error_len;
  char *tmp;
  assert (!private->error);
  tmp_len = strlen (s) + sizeof (u) * 4 + 1;
  NEWN (tmp, tmp_len);
  sprintf (tmp, s, u);
  error_len = strlen (tmp) + 1;
  NEWN (private->error, error_len);
  memcpy (private->error, tmp, error_len);
  DELETEN (tmp, tmp_len);
  return private->error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jne 0xa173
jmp 0xa192
leaq 0x28ec(%rip), %rdi      # 0xca66
leaq 0x2128(%rip), %rsi      # 0xc2a9
movl $0x23f, %edx            # imm = 0x23F
leaq 0x2953(%rip), %rcx      # 0xcae0
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x10b0
addq $0x10, %rax
addq $0x1, %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movb $0x0, %al
callq 0x1180
movq -0x28(%rbp), %rdi
callq 0x10b0
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x38(%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, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
movq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x1100
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x1140
movl -0x18(%rbp), %eax
shlq $0x0, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq *%rax
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
addq $0x40, %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_check_right_hand_side_defined
static void
aiger_check_right_hand_side_defined (aiger_private * private, aiger_and * and,
				     unsigned rhs)
{
  if (private->error)
    return;

  assert (and);
  if (!aiger_literal_defined (private, rhs))
    aiger_error_uu (private, "literal %u in AND %u undefined", rhs, and->lhs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0xa2d3
jmp 0xa325
cmpq $0x0, -0x10(%rbp)
je 0xa2dc
jmp 0xa2fb
leaq 0x2097(%rip), %rdi      # 0xc37a
leaq 0x1fbf(%rip), %rsi      # 0xc2a9
movl $0x2a6, %edx            # imm = 0x2A6
leaq 0x2885(%rip), %rcx      # 0xcb7b
callq 0x10f0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9f10
cmpl $0x0, %eax
jne 0xa325
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
leaq 0x28b0(%rip), %rsi      # 0xcbd0
callq 0x9fe0
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_write_symbols_aux
static int
aiger_write_symbols_aux (aiger * public,
			 void *state, aiger_put put,
			 const char *type,
			 aiger_symbol * symbols, unsigned size)
{
  unsigned i;

  for (i = 0; i < size; i++)
    {
      if (!symbols[i].name)
	continue;

      assert (symbols[i].name[0]);

      if (aiger_put_s (state, put, type) == EOF ||
	  aiger_put_u (state, put, i) == EOF ||
	  put (' ', state) == EOF ||
	  aiger_put_s (state, put, symbols[i].name) == EOF ||
	  put ('\n', state) == EOF)
	return 0;
    }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0xa445
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x18(%rax)
jne 0xa37d
jmp 0xa437
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
cmpb $0x0, (%rax)
je 0xa396
jmp 0xa3b5
leaq 0x28ee(%rip), %rdi      # 0xcc8b
leaq 0x1f05(%rip), %rsi      # 0xc2a9
movl $0x498, %edx            # imm = 0x498
leaq 0x28ee(%rip), %rcx      # 0xcc9e
callq 0x10f0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7380
cmpl $-0x1, %eax
je 0xa42c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x38(%rbp), %edx
callq 0xa460
cmpl $-0x1, %eax
je 0xa42c
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rsi
movl $0x20, %edi
callq *%rax
cmpl $-0x1, %eax
je 0xa42c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdx
callq 0x7380
cmpl $-0x1, %eax
je 0xa42c
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq *%rax
cmpl $-0x1, %eax
jne 0xa435
movl $0x0, -0x4(%rbp)
jmp 0xa44c
jmp 0xa437
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xa357
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %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_new_code
static void
aiger_new_code (unsigned var, unsigned *new, unsigned *code)
{
  unsigned lit = aiger_var2lit (var), res;
  assert (!code[lit]);
  res = *new;
  code[lit] = res;
  code[lit + 1] = res + 1;
  *new += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
jne 0xa4ca
jmp 0xa4e9
leaq 0x295a(%rip), %rdi      # 0xce2b
leaq 0x1dd1(%rip), %rsi      # 0xc2a9
movl $0x54d, %edx            # imm = 0x54D
leaq 0x2952(%rip), %rcx      # 0xce36
callq 0x10f0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %edx
addl $0x1, %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%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_write_delta
static int
aiger_write_delta (void *state, aiger_put put, unsigned delta)
{
  unsigned char ch;
  unsigned tmp = delta;

  while (tmp & ~0x7f)
    {
      ch = tmp & 0x7f;
      ch |= 0x80;

      if (put (ch, state) == EOF)
	return 0;

      tmp >>= 7;
    }

  ch = tmp;
  return put (ch, state) != EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $-0x80, %eax
cmpl $0x0, %eax
je 0xada2
movl -0x24(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %eax
orl $0x80, %eax
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movb -0x1d(%rbp), %cl
movq -0x10(%rbp), %rsi
movsbl %cl, %edi
callq *%rax
cmpl $-0x1, %eax
jne 0xad97
movl $0x0, -0x4(%rbp)
jmp 0xadc6
movl -0x24(%rbp), %eax
shrl $0x7, %eax
movl %eax, -0x24(%rbp)
jmp 0xad59
movl -0x24(%rbp), %eax
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movb -0x1d(%rbp), %cl
movq -0x10(%rbp), %rsi
movsbl %cl, %edi
callq *%rax
cmpl $-0x1, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_have_at_least_one_symbol_aux
static int
aiger_have_at_least_one_symbol_aux (aiger * public,
				    aiger_symbol * symbols, unsigned size)
{
  unsigned i;

  for (i = 0; i < size; i++)
    if (symbols[i].name)
      return 1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xae19
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x18(%rax)
je 0xae0c
movl $0x1, -0x4(%rbp)
jmp 0xae20
jmp 0xae0e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xade6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_next_ch
static int
aiger_next_ch (aiger_reader * reader)
{
  int res;

  res = reader->get (reader->state);

  if (isspace (reader->ch) && !isspace (res))
    reader->lineno_at_last_token_start = reader->lineno;

  reader->ch = res;

  if (reader->done_with_reading_header && reader->looks_like_aag)
    {
      if (!isspace (res) && !isdigit (res) && res != EOF)
	reader->looks_like_aag = 0;
    }

  if (res == '\n')
    reader->lineno++;

  if (res != EOF)
    reader->charno++;

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movl %eax, -0xc(%rbp)
callq 0x11a0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xae96
callq 0x11a0
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0xae96
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xaefb
movq -0x8(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0xaefb
callq 0x11a0
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0xaef9
callq 0x11a0
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xaef9
cmpl $-0x1, -0xc(%rbp)
je 0xaef9
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
jmp 0xaefb
cmpl $0xa, -0xc(%rbp)
jne 0xaf0e
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
cmpl $-0x1, -0xc(%rbp)
je 0xaf21
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)