LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kztomita[P]http-dump/./buffer_view.h
// Function: buffer_view<unsigned char>::at_uint16(unsigned long) const
uint16_t at_uint16(std::size_t offset) const {
    std::size_t end = offset + 1;
    if (end < offset || end >= length_) {
      throw std::range_error("invalid offset");
    }
    uint16_t value = 0;
    memcpy(&value, buffer_ + offset, 2);
    return ntohs(value);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x614cc
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jb 0x6151c
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x142a5(%rip), %rsi     # 0x7578c
callq 0xdb30
jmp 0x614ee
movq -0x38(%rbp), %rdi
movq 0x4bad7(%rip), %rsi     # 0xacfd0
movq 0x4ba18(%rip), %rdx     # 0xacf18
callq 0xd970
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xdc70
jmp 0x61544
movq -0x30(%rbp), %rax
movw $0x0, -0x26(%rbp)
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movw (%rax,%rcx), %ax
movw %ax, -0x26(%rbp)
movzwl -0x26(%rbp), %edi
callq 0xdfb0
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd990
nopl (%rax)
// File: kztomita[P]http-dump/hpack_decoder.cc
// Function: hpack::hpack_decoder::decode[abi:cxx11](hpack::decoding_context&)
hpack_decoder::header_list_type hpack_decoder::decode(decoding_context& context) {
  decode_pos_ = 0;

  header_list_type headers;
  while (true) {
    auto result = decode_representation(context);
    // Dynamic Table Size Updateの場合はヘッダはないが
    // result.endはfalseなので処理を続ける。
    if (result.header) {
      headers.push_back(result.header.value());
    }
    if (result.end) {
      break;
    }
  }

  return headers;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x0, 0x10(%rax)
movb $0x0, -0x19(%rbp)
callq 0x38d10
jmp 0x620c6
movq -0x88(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x621b0
jmp 0x620dc
leaq -0x70(%rbp), %rdi
callq 0x62cb0
testb $0x1, %al
jne 0x620eb
jmp 0x62139
leaq -0x70(%rbp), %rdi
callq 0x62d40
movq %rax, -0xa0(%rbp)
jmp 0x620fd
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x62cd0
jmp 0x62112
jmp 0x62139
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x62195
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x62d80
jmp 0x62195
testb $0x1, -0x28(%rbp)
je 0x62148
movl $0x3, -0x80(%rbp)
jmp 0x6214f
movl $0x0, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x62d80
movl -0x80(%rbp), %eax
testl %eax, %eax
je 0x62163
jmp 0x62161
jmp 0x62168
jmp 0x620c4
movb $0x1, -0x19(%rbp)
movl $0x1, -0x80(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x62185
movq -0x98(%rbp), %rdi
callq 0x38d30
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x38d30
movq -0x78(%rbp), %rdi
callq 0xd990
nopw (%rax,%rax)
// File: kztomita[P]http-dump/hpack_decoder.cc
// Function: hpack::(anonymous namespace)::parse_integer_representation(buffer_view<unsigned char> const&, unsigned long, unsigned long)
std::pair<int, std::size_t>
parse_integer_representation(const buffer_view<unsigned char>& buffer, std::size_t offset, std::size_t n) {
  // 2 ^ n - 1
  int value_mask = (1 << n) - 1;

  int value = buffer.at(offset) & value_mask;
  if (value < value_mask) {
    return std::pair(value, 1);
  }

  // 全bitが立っている

  std::size_t next = offset + 1;

  int m = 0;
  while (true) {
    int octet = buffer.at(next);
    next++;

    value += (octet & 0x7f) << m;
    m += 7;

    if (!(octet & 0x80)) {
      break;
    }
  }

  return std::pair(value, next - offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x612f0
movzbl %al, %eax
andl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x625fc
movl $0x1, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x62f80
leaq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x62fb0
jmp 0x62676
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x612f0
movzbl %al, %eax
movl %eax, -0x50(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %eax
andl $0x7f, %eax
movl -0x4c(%rbp), %ecx
shll %cl, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x4c(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x4c(%rbp)
movl -0x50(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x62657
jmp 0x62659
jmp 0x6260f
movq -0x48(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x62fe0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kztomita[P]http-dump/hpack_decoder.cc
// Function: hpack::hpack_decoder::fetch_header[abi:cxx11](hpack::decoding_context const&, unsigned long)
header_type hpack_decoder::fetch_header(const decoding_context& context, std::size_t index) {
  if (index) {
    // parse value string literal

    auto h = hpack_table_at(*context.dynamic_table, index);
    if (!h) {
      throw std::runtime_error("header not found in tables.");
    }

    // Value String
    std::string value = fetch_string();

    return header_type(h.value().first, value);
  } else {
    // parse name string literal and value string literal

    // Name String
    std::string name = fetch_string();

    // Value String
    std::string value = fetch_string();

    return header_type(name, value);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x62b3a
movq -0x18(%rbp), %rdi
callq 0x5a5d0
movq %rax, %rsi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x64250
leaq -0x68(%rbp), %rdi
callq 0x62cb0
testb $0x1, %al
jne 0x62ab7
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
leaq 0x12f34(%rip), %rsi     # 0x7599a
callq 0xd3b0
jmp 0x62a6d
movq -0xf8(%rbp), %rdi
movq 0x4a515(%rip), %rsi     # 0xacf90
movq 0x4a4de(%rip), %rdx     # 0xacf60
callq 0xd970
jmp 0x62be5
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0xdc70
jmp 0x62b2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x62b2c
movq -0xe0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x62690
jmp 0x62acc
leaq -0x68(%rbp), %rdi
callq 0x62d40
movq %rax, -0x100(%rbp)
jmp 0x62ade
movq -0x100(%rbp), %rsi
movq -0xf0(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x62dc0
jmp 0x62afa
leaq -0x98(%rbp), %rdi
callq 0xdac0
leaq -0x68(%rbp), %rdi
callq 0x62e20
jmp 0x62bcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xdac0
leaq -0x68(%rbp), %rdi
callq 0x62e20
jmp 0x62bdc
movq -0xe0(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x62690
movq -0xe0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x62690
jmp 0x62b62
movq -0xf0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x62dc0
jmp 0x62b7e
leaq -0xd8(%rbp), %rdi
callq 0xdac0
leaq -0xb8(%rbp), %rdi
callq 0xdac0
jmp 0x62bcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x62bbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0xdac0
leaq -0xb8(%rbp), %rdi
callq 0xdac0
jmp 0x62bdc
movq -0xe8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
nop
// File: kztomita[P]http-dump/./buffer_view.h
// Function: buffer_view<unsigned char>::subview(unsigned long, unsigned long) const
buffer_view subview(std::size_t offset, std::size_t length) const {
    std::size_t end = offset + length;
    if (end < offset || end > length_) {
      throw std::range_error("invalid offset or length");
    }
    return buffer_view(buffer_ + offset, length);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x63050
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x8(%rcx), %rax
jbe 0x630a0
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x12963(%rip), %rsi     # 0x759ce
callq 0xdb30
jmp 0x63072
movq -0x50(%rbp), %rdi
movq 0x49f53(%rip), %rsi     # 0xacfd0
movq 0x49e94(%rip), %rdx     # 0xacf18
callq 0xd970
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xdc70
jmp 0x630c9
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x612c0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kztomita[P]http-dump/hpack_table.cc
// Function: hpack::hpack_dynamic_table::calc_table_size() const
std::size_t hpack_dynamic_table::calc_table_size() const {
  std::size_t size = 0;
  for (const auto& e : entries_) {
    size += entry_size(e);
  }
  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x395e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x39610
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x39640
testb $0x1, %al
jne 0x63dbd
jmp 0x63dea
leaq -0x20(%rbp), %rdi
callq 0x39680
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x63d30
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x396f0
jmp 0x63daa
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kztomita[P]http-dump/hpack_table.cc
// Function: hpack::hpack_dynamic_table::at[abi:cxx11](unsigned long) const
header_type hpack_dynamic_table::at(std::size_t index) const {
  if (index >= size()) {
    throw std::invalid_argument("out of range.");
  }

  // 新しいエントリほど若いindexとする必要がある。
  // 性能的に新しいエントリは末尾に追加したいので、
  // indexは末尾を0とする形に変換する。
  return header_type(entries_[size() - 1 - index]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x63d10
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x63f70
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x11d53(%rip), %rsi     # 0x75c8e
callq 0xd2e0
jmp 0x63f42
movq -0x50(%rbp), %rdi
movq 0x48fdb(%rip), %rsi     # 0xacf28
movq 0x48fcc(%rip), %rdx     # 0xacf20
callq 0xd970
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xdc70
jmp 0x63fa3
movq -0x38(%rbp), %rdi
callq 0x63d10
movq -0x38(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
subq -0x18(%rbp), %rsi
callq 0x658e0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3a740
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd990
nopl (%rax)
// File: kztomita[P]http-dump/hpack_table.cc
// Function: hpack::hpack_dynamic_table::remove_tail()
void hpack_dynamic_table::remove_tail() {
  if (entries_.size() > 0) {
    // XXX vectorの先頭エントリ削除なので直したい
    current_table_size_ -= entry_size(*entries_.begin());
    entries_.erase(entries_.begin());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3a300
cmpq $0x0, %rax
jbe 0x6407a
movq -0x30(%rbp), %rdi
callq 0x3ff60
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x40290
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x63d30
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq 0x20(%rdi), %rax
subq %rcx, %rax
movq %rax, 0x20(%rdi)
callq 0x3ff60
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x65970
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x65900
movq %rax, -0x28(%rbp)
addq $0x30, %rsp
popq %rbp
retq
// File: kztomita[P]http-dump/hpack_table.cc
// Function: hpack::hpack_dynamic_table::dump() const
void hpack_dynamic_table::dump() const {
  std::cout << "Table Size: " << table_size() << " (Maximum:" << max_size_ << ")" << std::endl;

  auto calculated_size = calc_table_size();
  if (table_size() != calculated_size) {
    std::cout << "ERROR: Calculated Table Size mismatched (" << calculated_size << ")" << std::endl;
  }

  int i = 1;
  for (auto e = entries_.rbegin(); e != entries_.rend(); ++e) {
    std::cout << "[" << i << "] " << e->first << " " << e->second << std::endl;
    i++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x48ea5(%rip), %rdi     # 0xacf40
leaq 0x11bfa(%rip), %rsi     # 0x75c9c
callq 0xd860
movq -0x30(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x63e00
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xdf10
movq %rax, %rdi
leaq 0x11bdf(%rip), %rsi     # 0x75ca9
callq 0xd860
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xdf10
movq %rax, %rdi
leaq 0xf057(%rip), %rsi      # 0x73140
callq 0xd860
movq %rax, %rdi
movq 0x48ea0(%rip), %rsi     # 0xacf98
callq 0xde80
movq -0x30(%rbp), %rdi
callq 0x63d70
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x63e00
cmpq -0x10(%rbp), %rax
je 0x64156
movq 0x48e20(%rip), %rdi     # 0xacf40
leaq 0x11b8d(%rip), %rsi     # 0x75cb4
callq 0xd860
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xdf10
movq %rax, %rdi
leaq 0xeffe(%rip), %rsi      # 0x73140
callq 0xd860
movq %rax, %rdi
movq 0x48e47(%rip), %rsi     # 0xacf98
callq 0xde80
movq -0x30(%rbp), %rsi
movl $0x1, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x659b0
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x65a30
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x65a00
testb $0x1, %al
jne 0x6418d
jmp 0x64225
movq 0x48dac(%rip), %rdi     # 0xacf40
leaq 0x11b43(%rip), %rsi     # 0x75cde
callq 0xd860
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0xd4c0
movq %rax, %rdi
leaq 0x11b2b(%rip), %rsi     # 0x75ce0
callq 0xd860
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x65a80
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xd480
movq %rax, %rdi
leaq 0x116c5(%rip), %rsi     # 0x758a2
callq 0xd860
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x65a80
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0xd480
movq %rax, %rdi
movq 0x48d8f(%rip), %rsi     # 0xacf98
callq 0xde80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x65ac0
jmp 0x6416a
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kztomita[P]http-dump/hpack_table.cc
// Function: hpack::hpack_table_at[abi:cxx11](hpack::hpack_dynamic_table const&, unsigned long)
std::optional<hpack::header_type>
hpack_table_at(const hpack_dynamic_table& dynamic_table, std::size_t index) {
  if (index == 0) {
    return std::nullopt;
  }
  if (index >= 1 && index <= hpack_static_table.size()) {
    return std::make_optional(hpack_static_table_at(index));
  }
  if (index >= hpack_static_table.size() + 1 && index <= hpack_static_table.size() + dynamic_table.size()) {
    return std::make_optional(dynamic_table.at(index - hpack_static_table.size() - 1));
  }
  return std::nullopt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x64290
movq -0xb8(%rbp), %rdi
callq 0x638a0
jmp 0x643c6
cmpq $0x1, -0x18(%rbp)
jb 0x642e8
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq 0x4a56f(%rip), %rdi     # 0xae818
callq 0x3a300
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
ja 0x642e8
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x63c40
movq -0xb8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x65af0
leaq -0x60(%rbp), %rdi
callq 0x38f50
jmp 0x643c6
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq 0x4a51e(%rip), %rdi     # 0xae818
callq 0x3a300
movq %rax, %rcx
movq -0xc8(%rbp), %rax
addq $0x1, %rcx
cmpq %rcx, %rax
jb 0x643ba
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq 0x4a4f0(%rip), %rdi     # 0xae818
callq 0x3a300
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63d10
movq -0xd8(%rbp), %rcx
movq %rax, %rdx
movq -0xd0(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0x643ba
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq 0x4a4a5(%rip), %rdi     # 0xae818
callq 0x3a300
movq -0xe8(%rbp), %rdx
movq -0xe0(%rbp), %rsi
subq %rax, %rdx
subq $0x1, %rdx
leaq -0xa0(%rbp), %rdi
callq 0x63ee0
movq -0xb8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x65af0
leaq -0xa0(%rbp), %rdi
callq 0x38f50
jmp 0x643c6
movq -0xb8(%rbp), %rdi
callq 0x638a0
movq -0xb0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kztomita[P]http-dump/hpack_huffman.cc
// Function: hpack::(anonymous namespace)::create_huffman_tree()
std::unique_ptr<huffman_tree> create_huffman_tree() {
  auto tree(std::make_unique<huffman_tree>());

  int i = 0;
  while (huffman_codes[i].len) {
    tree->insert_code(huffman_codes[i], i);
    i++;
  }

  return tree;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x663c0
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x47d2e(%rip), %rax     # 0xaddb0
cmpl $0x0, (%rax,%rcx,8)
je 0x660ce
movq -0x30(%rbp), %rdi
callq 0x66380
movq %rax, %rdi
movslq -0x10(%rbp), %rcx
movl %ecx, %edx
leaq 0x47d0f(%rip), %rax     # 0xaddb0
leaq (%rax,%rcx,8), %rsi
callq 0x66430
jmp 0x660ac
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x66077
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x66100
jmp 0x660eb
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x660e1
movq -0x30(%rbp), %rdi
callq 0x66100
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
// File: kztomita[P]http-dump/hpack_huffman.cc
// Function: hpack::(anonymous namespace)::huffman_tree::insert_code(hpack::huffman_code const&, int)
void insert_code(const huffman_code& code, int value) {
    tree_node* node = root_.get();

    for (unsigned int i = 0 ; i < code.len ; i++) {

      if (!((code.bits >> (code.len - i - 1)) & 0x1)) {
        if (!node->left) {
          // ノード追加
          if (node->value != -1) {
            throw std::logic_error("incorrect code.");
          }
          node->left = std::make_unique<tree_node>();
        }
        node = node->left.get();
      } else {
        if (!node->right) {
          // ノード追加
          if (node->value != -1) {
            throw std::logic_error("incorrect code.");
          }
          node->right = std::make_unique<tree_node>();
        }
        node = node->right.get();
      }
    }
    node->value = value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x66a00
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x665d1
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl -0x24(%rbp), %ecx
subl $0x1, %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x66522
movq -0x20(%rbp), %rdi
callq 0x669d0
testb $0x1, %al
jne 0x66510
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x10(%rax)
je 0x664f1
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0xf838(%rip), %rsi      # 0x75cf1
callq 0xdba0
jmp 0x664c0
movq -0x50(%rbp), %rdi
movq 0x46b0d(%rip), %rsi     # 0xacfd8
movq 0x46ade(%rip), %rdx     # 0xacfb0
callq 0xd970
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xdc70
jmp 0x665e1
leaq -0x40(%rbp), %rdi
callq 0x66a30
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x66d30
leaq -0x40(%rbp), %rdi
callq 0x66d60
movq -0x20(%rbp), %rdi
callq 0x66a00
movq %rax, -0x20(%rbp)
jmp 0x665c1
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x669d0
testb $0x1, %al
jne 0x665b0
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x10(%rax)
je 0x6658d
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0xf799(%rip), %rsi      # 0x75cf1
callq 0xdba0
jmp 0x6655f
movq -0x58(%rbp), %rdi
movq 0x46a6e(%rip), %rsi     # 0xacfd8
movq 0x46a3f(%rip), %rdx     # 0xacfb0
callq 0xd970
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xdc70
jmp 0x665e1
leaq -0x48(%rbp), %rdi
callq 0x66a30
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
leaq -0x48(%rbp), %rsi
callq 0x66d30
leaq -0x48(%rbp), %rdi
callq 0x66d60
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x66a00
movq %rax, -0x20(%rbp)
jmp 0x665c3
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x66457
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xd990
nopw (%rax,%rax)
// File: kztomita[P]http-dump/sync_stream_wrapper.cc
// Function: ssl_stream::ssl_stream(bool, bool)
ssl_stream::ssl_stream(bool verify_cert, bool http2)
  : ssl_context_(asio::ssl::context::tlsv12_client),
    verify_cert_(verify_cert),
    host_("localhost") {

  ssl_context_.set_default_verify_paths();

  auto native_ctx = ssl_context_.native_handle();

  if (http2) {
    SSL_CTX_set_alpn_protos(native_ctx, (const unsigned char *)"\x02h2", 3);
  }

  if (g_keylog_file) {
    SSL_CTX_set_keylog_callback(native_ctx, ssl_keylog_callback);
  }

  stream_.reset(new socket_type(io_context_, ssl_context_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x678c0
movq -0x38(%rbp), %rdi
leaq 0x450e4(%rip), %rax     # 0xac388
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x10ca0
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
movl $0x10, %esi
callq 0x67b40
jmp 0x672cc
movq -0x38(%rbp), %rax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
addq $0x38, %rax
movq %rax, -0x50(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xddb0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xeaa3(%rip), %rsi      # 0x75da0
callq 0x10a30
jmp 0x67304
leaq -0x1d(%rbp), %rdi
callq 0xe180
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x58(%rbp)
callq 0x68530
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x68560
jmp 0x6732d
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x685b0
movq %rax, -0x60(%rbp)
jmp 0x67340
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0xa(%rbp)
je 0x673a3
movq -0x28(%rbp), %rdi
leaq 0xea51(%rip), %rsi      # 0x75daa
movl $0x3, %edx
callq 0xdea0
jmp 0x67365
jmp 0x673a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x6743f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0xe180
jmp 0x67436
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x67424
cmpq $0x0, 0x47265(%rip)     # 0xae610
je 0x673c1
movq -0x28(%rbp), %rdi
leaq 0xa8(%rip), %rsi        # 0x67460
callq 0xd430
jmp 0x673bf
jmp 0x673c1
movq -0x38(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x70(%rbp)
movl $0x1a0, %edi            # imm = 0x1A0
callq 0xd240
movq %rax, -0x68(%rbp)
jmp 0x673dd
movq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq %rdx, %rsi
addq $0x8, %rsi
addq $0x18, %rdx
callq 0x68600
jmp 0x673f7
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x685d0
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x1a0, %esi            # imm = 0x1A0
callq 0xd1b0
movq -0x58(%rbp), %rdi
callq 0x50280
movq -0x50(%rbp), %rdi
callq 0xdac0
movq -0x30(%rbp), %rdi
callq 0x502f0
movq -0x40(%rbp), %rdi
callq 0x11200
movq -0x18(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
// File: kztomita[P]http-dump/sync_stream_wrapper.cc
// Function: (anonymous namespace)::ssl_keylog_callback(ssl_st const*, char const*)
void ssl_keylog_callback(const SSL *ssl, const char *line) {
  std::ofstream fs(g_keylog_file, std::ios_base::out | std::ios_base::app);
  if (!fs) {
    std::cerr << "Can't open " << g_keylog_file << std::endl;
  }

  fs << line << std::endl;

  fs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x47196(%rip), %rax     # 0xae610
movq %rax, -0x228(%rbp)
movl $0x10, %edi
movl $0x1, %esi
callq 0x68d30
movq -0x228(%rbp), %rsi
movl %eax, %edx
leaq -0x210(%rbp), %rdi
callq 0xd4b0
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0xd090
movb %al, -0x21d(%rbp)
jmp 0x674c5
movb -0x21d(%rbp), %al
testb $0x1, %al
jne 0x674d1
jmp 0x67540
movq 0x45ad0(%rip), %rdi     # 0xacfa8
leaq 0xe8fc(%rip), %rsi      # 0x75ddb
callq 0xd860
movq %rax, -0x230(%rbp)
jmp 0x674ed
movq -0x230(%rbp), %rdi
movq 0x47115(%rip), %rsi     # 0xae610
callq 0xd860
movq %rax, -0x238(%rbp)
jmp 0x67509
movq -0x238(%rbp), %rdi
movq 0x45a81(%rip), %rsi     # 0xacf98
callq 0xde80
jmp 0x6751e
jmp 0x67540
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0xdaf0
jmp 0x67591
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0xd860
movq %rax, -0x240(%rbp)
jmp 0x67559
movq -0x240(%rbp), %rdi
movq 0x45a31(%rip), %rsi     # 0xacf98
callq 0xde80
jmp 0x6756e
leaq -0x210(%rbp), %rdi
callq 0xdd10
jmp 0x6757c
leaq -0x210(%rbp), %rdi
callq 0xdaf0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0xd990
nopl (%rax)
// File: kztomita[P]http-dump/sync_stream_wrapper.cc
// Function: ssl_stream::connect(boost::asio::ip::address const&, unsigned short)
void ssl_stream::connect(const boost::asio::ip::address& ip, uint16_t port) {
  stream_->lowest_layer().connect(asio::ip::tcp::endpoint(ip, port));

  if (verify_cert_) {
    // for SNI
    SSL_set_tlsext_host_name(stream_->native_handle(), host_.c_str());

    stream_->set_verify_mode(asio::ssl::verify_peer);
    stream_->set_verify_callback(asio::ssl::rfc2818_verification(host_));
  }

  stream_->handshake(asio::ssl::stream_base::client);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x58, %rdi
callq 0x68700
movq %rax, %rdi
callq 0x68720
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movzwl -0x12(%rbp), %edx
callq 0x679e0
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x67910
movq -0x68(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x676f0
movq -0x68(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x90(%rbp)
callq 0x68700
movq %rax, %rdi
callq 0x596c0
movq -0x68(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x38, %rdi
movq %rdi, -0x88(%rbp)
callq 0xd1a0
movq -0x98(%rbp), %rdi
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
movl $0x37, %esi
callq 0xd950
movq -0x90(%rbp), %rdi
callq 0x68700
movq %rax, %rdi
movl $0x1, %esi
callq 0x68740
movq -0x90(%rbp), %rdi
callq 0x68700
movq -0x88(%rbp), %rsi
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x68850
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x68790
jmp 0x676ce
leaq -0x50(%rbp), %rdi
callq 0x68880
jmp 0x676f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x68880
jmp 0x67710
movq -0x68(%rbp), %rdi
addq $0x58, %rdi
callq 0x68700
movq %rax, %rdi
xorl %esi, %esi
callq 0x688a0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xd990
nopl (%rax)
// File: kztomita[P]http-dump/dump.cc
// Function: dump(void const*, unsigned long, unsigned long)
void dump(const void* p, std::size_t size, std::size_t max = 0) {
  const char* p2 = reinterpret_cast<const char*>(p);

  std::size_t last_offset = size;
  bool snip = false;
  if (max && size > max) {
    last_offset = max;
    snip = true;
  }

  for (std::size_t offset = 0 ; offset < last_offset ; offset += 16) {
    if (offset + 16 <= last_offset) {
      out_line(p2 + offset, p2 + offset + 16, false);
    } else {
      out_line(p2 + offset, p2 + last_offset, snip);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x72b55
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x72b55
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x72bbf
movq -0x38(%rbp), %rax
addq $0x10, %rax
cmpq -0x28(%rbp), %rax
ja 0x72b92
movq -0x20(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x38(%rbp), %rsi
addq $0x10, %rsi
xorl %edx, %edx
callq 0x72bd0
jmp 0x72baf
movq -0x20(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x28(%rbp), %rsi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x72bd0
jmp 0x72bb1
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
jmp 0x72b5d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_load_buffer_state()
void yyFlexLexer::yy_load_buffer_state()
{
    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin.rdbuf(YY_CURRENT_BUFFER_LVALUE->yy_input_file);
	(yy_hold_char) = *(yy_c_buf_p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x25c(%rcx)
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rdx
movq (%rax,%rdx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x260(%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, %rdi
addq $0x30, %rdi
movq 0x30(%rcx), %rax
addq -0x18(%rax), %rdi
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x44e0
movq -0x10(%rbp), %rax
movq 0x260(%rax), %rcx
movb (%rcx), %cl
movb %cl, 0x258(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_try_NUL_trans(int)
yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 100 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 99);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x260(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x10d73(%rip), %rax     # 0x161c0
cmpw $0x0, (%rax,%rcx,2)
je 0x546c
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x290(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x298(%rax)
jmp 0x546e
movslq -0xc(%rbp), %rcx
leaq 0x10f47(%rip), %rax     # 0x163c0
movswl (%rax,%rcx,2), %eax
movzbl -0x19(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x10e03(%rip), %rax     # 0x16290
movswl (%rax,%rcx,2), %eax
cmpl -0xc(%rbp), %eax
je 0x54c3
movslq -0xc(%rbp), %rcx
leaq 0x10fef(%rip), %rax     # 0x16490
movswl (%rax,%rcx,2), %eax
movl %eax, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jl 0x54c1
movzbl -0x19(%rbp), %eax
movl %eax, %ecx
leaq 0x110a5(%rip), %rax     # 0x16560
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
jmp 0x546e
movslq -0xc(%rbp), %rcx
leaq 0x10ef2(%rip), %rax     # 0x163c0
movswl (%rax,%rcx,2), %eax
movzbl -0x19(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x110ae(%rip), %rax     # 0x16590
movswl (%rax,%rcx,2), %eax
movl %eax, -0xc(%rbp)
cmpl $0x63, -0xc(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x5505
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x550b
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
popq %rbp
retq
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::ctor_common()
void yyFlexLexer::ctor_common()
{
	yy_c_buf_p = 0;
	yy_init = 0;
	yy_start = 0;
	yy_flex_debug = 0;
	yylineno = 1;	// this will only get updated if %option yylineno

	yy_did_buffer_switch_on_eof = 0;

	yy_looking_for_trail_begin = 0;
	yy_more_flag = 0;
	yy_more_len = 0;
	yy_more_offset = yy_prev_more_offset = 0;

	yy_start_stack_ptr = yy_start_stack_depth = 0;
	yy_start_stack = NULL;

	yy_buffer_stack = NULL;
	yy_buffer_stack_top = 0;
	yy_buffer_stack_max = 0;

	yy_state_buf = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x260(%rax)
movl $0x0, 0x268(%rax)
movl $0x0, 0x26c(%rax)
movl $0x0, 0x18(%rax)
movl $0x1, 0x14(%rax)
movl $0x0, 0x270(%rax)
movl $0x0, 0x2c8(%rax)
movl $0x0, 0x2cc(%rax)
movl $0x0, 0x2d0(%rax)
movl $0x0, 0x2d8(%rax)
movl $0x0, 0x2d4(%rax)
movl $0x0, 0x20(%rax)
movl $0x0, 0x1c(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x288(%rax)
movq $0x0, 0x278(%rax)
movq $0x0, 0x280(%rax)
movq $0x0, 0x2a0(%rax)
popq %rbp
retq
nopl (%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::~yyFlexLexer()
yyFlexLexer::~yyFlexLexer()
{
	delete [] yy_state_buf;
	yyfree( yy_start_stack  );
	yy_delete_buffer( YY_CURRENT_BUFFER );
	yyfree( yy_buffer_stack  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x19b4d(%rip), %rcx     # 0x1f858
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x2a0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5d2c
movq -0x10(%rbp), %rdi
callq 0x4370
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x5dd0
jmp 0x5d3b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x288(%rax)
je 0x5d65
movq -0x18(%rbp), %rcx
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x5d6d
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x5d6d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x5d80
movq -0x18(%rbp), %rax
movq 0x288(%rax), %rdi
callq 0x5dd0
jmp 0x5d92
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x4410
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x4440
movq -0x18(%rbp), %rdi
callq 0x6e30
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6e20
nopw %cs:(%rax,%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::switch_streams(std::istream&, std::ostream&)
void yyFlexLexer::switch_streams( std::istream& new_in, std::ostream& new_out )
{
	// was if( new_in )
	yy_delete_buffer( YY_CURRENT_BUFFER );
	yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE  ) );

	// was if( new_out )
	yyout.rdbuf(new_out.rdbuf());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x288(%rax)
je 0x5e62
movq -0x20(%rbp), %rcx
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x5e6a
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x5e6a
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movl $0x4000, %edx           # imm = 0x4000
callq *0x20(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $0x148, %rax            # imm = 0x148
movq 0x148(%rcx), %rcx
addq -0x18(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4160
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x44e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::switch_streams(std::istream*, std::ostream*)
void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
{
	if( ! new_in ) {
		new_in = &yyin;
	}

	if ( ! new_out ) {
		new_out = &yyout;
	}

	switch_streams(*new_in, *new_out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5f0f
movq -0x20(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5f24
movq -0x20(%rbp), %rax
addq $0x148, %rax            # imm = 0x148
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::LexerInput(char*, int)
int yyFlexLexer::LexerInput( char* buf, int max_size )
#endif
{
	if ( yyin.eof() || yyin.fail() )
		return 0;

#ifdef YY_INTERACTIVE
	yyin.get( buf[0] );

	if ( yyin.eof() )
		return 0;

	if ( yyin.bad() )
		return -1;

	return 1;

#else
	(void) yyin.read( buf, max_size );

	if ( yyin.bad() )
		return -1;
	else
		return yyin.gcount();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rdi
addq $0x30, %rdi
movq 0x30(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x44d0
testb $0x1, %al
jne 0x5f91
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq 0x30(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x4030
testb $0x1, %al
jne 0x5f91
jmp 0x5f9a
movl $0x0, -0x4(%rbp)
jmp 0x6000
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x43b0
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq 0x30(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x44d0
testb $0x1, %al
jne 0x5fc9
jmp 0x5fd2
movl $0x0, -0x4(%rbp)
jmp 0x6000
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq 0x30(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x44a0
testb $0x1, %al
jne 0x5ff0
jmp 0x5ff9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6000
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyrestart(std::istream&)
void yyFlexLexer::yyrestart( std::istream& input_file )
{
    
	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack ();
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE );
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
	yy_load_buffer_state(  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x288(%rax)
je 0x644e
movq -0x18(%rbp), %rcx
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x6456
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x6456
movq -0x20(%rbp), %rax
cmpq $0x0, %rax
jne 0x6498
movq -0x18(%rbp), %rdi
callq 0x5100
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x30, %rsi
movq (%rdi), %rax
movl $0x4000, %edx           # imm = 0x4000
callq *0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rax, %rdx
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x288(%rax)
je 0x64c2
movq -0x18(%rbp), %rcx
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x64ca
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x64ca
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x64f0
movq -0x18(%rbp), %rdi
callq 0x5250
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_init_buffer(yy_buffer_state*, std::istream&)
void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream& file )

{
	int oerrno = errno;
    
	yy_flush_buffer( b );

	b->yy_input_file = file.rdbuf();
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

	b->yy_is_interactive = 0;
	errno = oerrno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x4060
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
callq 0x68e0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4160
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movl $0x1, 0x34(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, 0x288(%rax)
je 0x657a
movq -0x30(%rbp), %rcx
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0x6582
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x6582
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq %rcx, %rax
je 0x65a5
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x4060
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_create_buffer(std::istream&, int)
YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream& file, int size )
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file );

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x40, %edi
callq 0x67e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6771
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
leaq 0x10121(%rip), %rsi     # 0x1688f
callq *0x70(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x67e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x67b4
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
leaq 0x100de(%rip), %rsi     # 0x1688f
callq *0x70(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x64f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_delete_buffer(yy_buffer_state*)
void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
{
    
	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree( (void *) b->yy_ch_buf  );

	yyfree( (void *) b  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6854
jmp 0x68d5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, 0x288(%rax)
je 0x6886
movq -0x18(%rbp), %rcx
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x688e
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x688e
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x68b5
movq -0x18(%rbp), %rcx
movq 0x288(%rcx), %rax
movq 0x278(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x68cc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5dd0
movq -0x10(%rbp), %rdi
callq 0x5dd0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yy_push_state(int)
void yyFlexLexer::yy_push_state( int _new_state )
{
    	if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
		{
		yy_size_t new_size;

		(yy_start_stack_depth) += YY_START_STACK_INCR;
		new_size = (yy_size_t) (yy_start_stack_depth) * sizeof( int );

		if ( ! (yy_start_stack) )
			(yy_start_stack) = (int *) yyalloc( new_size  );

		else
			(yy_start_stack) = (int *) yyrealloc(
					(void *) (yy_start_stack), new_size  );

		if ( ! (yy_start_stack) )
			YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
		}

	(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;

	BEGIN(_new_state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x1c(%rcx), %eax
cmpl 0x20(%rcx), %eax
jl 0x6caf
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x19, %ecx
movl %ecx, 0x20(%rax)
movslq 0x20(%rax), %rcx
shlq $0x2, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x28(%rax)
jne 0x6c75
movq -0x18(%rbp), %rdi
callq 0x67e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x6c91
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6050
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x6cad
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
leaq 0xfc42(%rip), %rsi      # 0x168ec
callq *0x70(%rax)
jmp 0x6caf
movq -0x20(%rbp), %rax
movl 0x26c(%rax), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
movl 0x1c(%rax), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, 0x1c(%rax)
movslq %edx, %rdx
movl %esi, (%rcx,%rdx,4)
movl -0xc(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, 0x26c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)