LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kztomita[P]http-dump/http2_frame.cc
// Function: (anonymous namespace)::dump_headers_payload(std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned char)
void dump_headers_payload(const http2_frame::payload_type& payload, uint8_t flags) {
  auto buffer = buffer_view(&payload[0], payload.size());

  std::size_t offset = 0;

  if (flags & 0x08) {  // PADDED
    std::cout << "Pad Length: " << buffer.at(offset) << std::endl;
    offset++;
  }
  if (flags & 0x20) {  // PRIORITY
    uint32_t dependency = buffer.at_uint32(offset);
    uint8_t weight =  buffer.at_uint32(offset + 4);
    std::cout << "E: " << ((dependency & 0x80000000) ? 1 : 0) << std::endl
              << "Stream Dependency: " << (dependency & 0x7fffffff) << std::endl
              << "Weight: " << weight << std::endl;
    offset += 5;
  }
  // HEADERSは複数フレームになることがあるので、Header Block Fragmentは
  // ここでは出力できない
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
testb $0x8, %bl
jne 0x23fe9
xorl %r15d, %r15d
jmp 0x24020
movq 0x21f88(%rip), %rdi     # 0x45f78
leaq 0x965b(%rip), %rsi      # 0x2d652
callq 0xb5e0
movq %rax, %r14
movq %rsp, %rdi
xorl %esi, %esi
callq 0x24574
movsbl %al, %esi
movq %r14, %rdi
callq 0xb780
movq %rax, %rdi
callq 0xb320
pushq $0x1
popq %r15
testb $0x20, %bl
je 0x240bf
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x245d0
movl %eax, %r14d
orq $0x4, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x245d0
movl %eax, %ebx
movq 0x21f26(%rip), %rdi     # 0x45f78
leaq 0x9737(%rip), %rsi      # 0x2d790
callq 0xb5e0
movl %r14d, %esi
shrl $0x1f, %esi
movq %rax, %rdi
callq 0xbb70
movq %rax, %rdi
callq 0xb320
leaq 0x95e4(%rip), %rsi      # 0x2d65f
movq %rax, %rdi
callq 0xb5e0
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq %rax, %rdi
movq %r14, %rsi
callq 0xb470
movq %rax, %rdi
callq 0xb320
leaq 0x95cf(%rip), %rsi      # 0x2d673
movq %rax, %rdi
callq 0xb5e0
movsbl %bl, %esi
movq %rax, %rdi
callq 0xb780
movq %rax, %rdi
callq 0xb320
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/kztomita[P]http-dump/http2_frame.cc
// Function: (anonymous namespace)::stringify_error_code[abi:cxx11](unsigned int)
std::string stringify_error_code(uint32_t code) {
  switch (code) {
  case NO_ERROR:
    return std::string("NO ERROR");
  case PROTOCOL_ERROR:
    return std::string("PROTOCOL ERROR");
  case INTERNAL_ERROR:
    return std::string("INTERNAL ERROR");
  case FLOW_CONTROL_ERROR:
    return std::string("FLOW CONTROL ERROR");
  case SETTINGS_TIMEOUT:
    return std::string("SETTINGS TIMEOUT");
  case STREAM_CLOSED:
    return std::string("STREAM CLOSED");
  case FRAME_SIZE_ERROR:
    return std::string("FRAME SIZE ERROR");
  case REFUSED_STREAM:
    return std::string("REFUSED STREAM");
  case CANCEL:
    return std::string("CANCEL");
  case COMPRESSION_ERROR:
    return std::string("COMPRESSION ERROR");
  case CONNECT_ERROR:
    return std::string("CONNECT ERROR");
  case ENHANCE_YOUR_CALM:
    return std::string("ENHANCE YOUR CALM");
  case INADEQUATE_SECURITY:
    return std::string("INADEQUATE SECURITY");
  case HTTP_1_1_REQUIRED:
    return std::string("HTTP1.1 REQUIRED");
  default:
    return std::string("Unknown");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0xd, %esi
ja 0x2444d
movl %esi, %eax
leaq 0x91df(%rip), %rcx      # 0x2d550
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9317(%rip), %rsi      # 0x2d698
leaq 0xf(%rsp), %rdx
jmp 0x24459
leaq 0x93a6(%rip), %rsi      # 0x2d738
leaq 0x4(%rsp), %rdx
jmp 0x24459
leaq 0x932f(%rip), %rsi      # 0x2d6d2
leaq 0xb(%rsp), %rdx
jmp 0x24459
leaq 0x9396(%rip), %rsi      # 0x2d74a
leaq 0x3(%rsp), %rdx
jmp 0x24459
leaq 0x9353(%rip), %rsi      # 0x2d718
leaq 0x6(%rsp), %rdx
jmp 0x24459
leaq 0x92da(%rip), %rsi      # 0x2d6b0
leaq 0xd(%rsp), %rdx
jmp 0x24459
leaq 0x92db(%rip), %rsi      # 0x2d6bf
leaq 0xc(%rsp), %rdx
jmp 0x24459
leaq 0x9310(%rip), %rsi      # 0x2d702
leaq 0x8(%rsp), %rdx
jmp 0x24459
leaq 0x92a1(%rip), %rsi      # 0x2d6a1
leaq 0xe(%rsp), %rdx
jmp 0x24459
leaq 0x92d5(%rip), %rsi      # 0x2d6e3
leaq 0xa(%rsp), %rdx
jmp 0x24459
leaq 0x9342(%rip), %rsi      # 0x2d75e
leaq 0x2(%rsp), %rdx
jmp 0x24459
leaq 0x92c7(%rip), %rsi      # 0x2d6f1
leaq 0x9(%rsp), %rdx
jmp 0x24459
leaq 0x92f2(%rip), %rsi      # 0x2d72a
leaq 0x5(%rsp), %rdx
jmp 0x24459
leaq 0x92cb(%rip), %rsi      # 0x2d711
leaq 0x7(%rsp), %rdx
jmp 0x24459
leaq 0x931b(%rip), %rsi      # 0x2d76f
leaq 0x1(%rsp), %rdx
movq %rbx, %rdi
callq 0xd416
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/kztomita[P]http-dump/./string_util_join.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> string_util::join<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(char const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::string join(const char* delimiter, const Container& c) {
  std::ostringstream os;
  if (!c.empty()) {
    auto last = std::prev(c.cend());
    std::copy(c.cbegin(), last, std::ostream_iterator<std::string>(os, ","));
    os << *last;
  }
  return os.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xb8f0
movq (%r14), %rsi
movq 0x8(%r14), %r14
cmpq %r14, %rsi
je 0x24517
addq $-0x20, %r14
leaq 0x18(%rsp), %rcx
movq %r15, (%rcx)
leaq 0x914e(%rip), %rax      # 0x2d647
movq %rax, 0x8(%rcx)
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x246a2
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xb570
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xbaa0
leaq 0x28(%rsp), %rdi
callq 0xb120
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x24542
jmp 0x24542
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb120
movq %rbx, %rdi
callq 0xbba0
nop
// File: /workspace/github_cpp_makefile_star2_O2/kztomita[P]http-dump/./buffer_view.h
// Function: buffer_view<unsigned char>::at_uint32(unsigned long) const
uint32_t at_uint32(std::size_t offset) const {
    std::size_t end = offset + 3;
    if (end < offset || end >= length_) {
      throw std::range_error("invalid offset");
    }
    uint32_t value = 0;
    memcpy(&value, buffer_ + offset, 4);
    return ntohl(value);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $-0x4, %rsi
ja 0x245f4
leaq 0x3(%rsi), %rax
cmpq 0x8(%rdi), %rax
jae 0x245f4
movq (%rdi), %rax
movl (%rax,%rsi), %eax
bswapl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xb330
movq %rax, %rbx
leaq 0x9076(%rip), %rsi      # 0x2d67c
movq %rax, %rdi
callq 0xbb60
movq 0x21983(%rip), %rsi     # 0x45f98
movq 0x2191c(%rip), %rdx     # 0x45f38
movq %rbx, %rdi
callq 0xbb50
movq %rax, %r14
movq %rbx, %rdi
callq 0xb4d0
movq %r14, %rdi
callq 0xbba0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpq $-0x1, %rsi
je 0x2465f
leaq 0x1(%rsi), %rax
cmpq 0x8(%rdi), %rax
jae 0x2465f
movq (%rdi), %rax
movzwl (%rax,%rsi), %eax
rolw $0x8, %ax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xb330
movq %rax, %rbx
leaq 0x900b(%rip), %rsi      # 0x2d67c
movq %rax, %rdi
callq 0xbb60
movq 0x21918(%rip), %rsi     # 0x45f98
movq 0x218b1(%rip), %rdx     # 0x45f38
movq %rbx, %rdi
callq 0xbb50
movq %rax, %r14
movq %rbx, %rdi
callq 0xb4d0
movq %r14, %rdi
callq 0xbba0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
andq $0x0, 0x10(%rsi)
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2486e
cmpb $0x1, 0x40(%rsp)
jne 0x2482c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24dc8
movb 0x48(%rsp), %bpl
movq %r12, %rdi
callq 0x24eea
testb %bpl, %bpl
je 0x2480c
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x24eea
jmp 0x2485e
movq %rax, %r14
movq %rbx, %rdi
callq 0x178fa
movq %r14, %rdi
callq 0xbba0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r13
shll %cl, %r13d
notl %r13d
callq 0x24574
movzbl %al, %ebp
andl %r13d, %ebp
cmpl %r13d, %ebp
jne 0x24a6a
xorl %r12d, %r12d
pushq $0x1
popq %r15
movl %r13d, %ebp
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x24574
movl %eax, %ecx
andb $0x7f, %cl
movzbl %cl, %edx
movl %r12d, %ecx
shll %cl, %edx
addl %edx, %ebp
addl $0x7, %r12d
incq %r15
testb %al, %al
js 0x24a42
jmp 0x24a6e
pushq $0x1
popq %r15
movl %ebp, %eax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x24cae
movq (%rdx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
callq 0x25389
cmpb $0x0, 0x40(%r15)
je 0x24cfb
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x24a82
cmpb $0x0, 0x68(%rsp)
je 0x24d2b
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x24df4
leaq 0x8(%rsp), %rdi
callq 0xb2f0
leaq 0x28(%rsp), %rdi
callq 0x24eea
jmp 0x24cee
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x24a82
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x24a82
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x24df4
leaq 0x8(%rsp), %rdi
callq 0xb2f0
leaq 0x28(%rsp), %rdi
callq 0xb2f0
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0xb330
movq %rax, %r14
leaq 0x8b7d(%rip), %rsi      # 0x2d88a
movq %rax, %rdi
callq 0xb270
movq 0x212cc(%rip), %rsi     # 0x45fe8
movq 0x21225(%rip), %rdx     # 0x45f48
movq %r14, %rdi
callq 0xbb50
callq 0x20d49
jmp 0x24d5d
movq %rax, %rbx
movq %r14, %rdi
callq 0xb4d0
jmp 0x24d6f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb2f0
jmp 0x24d51
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb2f0
jmp 0x24d79
movq %rax, %rbx
jmp 0x24d6f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb2f0
leaq 0x28(%rsp), %rdi
callq 0x24eea
movq %rbx, %rdi
callq 0xbba0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
addq %rsi, %rax
jb 0x24e4a
cmpq 0x8(%rdi), %rax
ja 0x24e4a
addq (%rdi), %rsi
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xb330
movq %rax, %rbx
leaq 0x8a62(%rip), %rsi      # 0x2d8be
movq %rax, %rdi
callq 0xbb60
movq 0x2112d(%rip), %rsi     # 0x45f98
movq 0x210c6(%rip), %rdx     # 0x45f38
movq %rbx, %rdi
callq 0xbb50
movq %rax, %r14
movq %rbx, %rdi
callq 0xb4d0
movq %r14, %rdi
callq 0xbba0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20d0d(%rip), %rdi     # 0x45f78
leaq 0x8919(%rip), %rsi      # 0x2db8b
callq 0xb5e0
movq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0xb470
leaq 0x890e(%rip), %rsi      # 0x2db98
movq %rax, %rdi
callq 0xb5e0
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0xb470
leaq 0x5e7a(%rip), %rsi      # 0x2b11f
movq %rax, %rdi
callq 0xb5e0
movq %rax, %rdi
callq 0xb320
movq %rbx, %rdi
callq 0x25118
cmpq %rax, 0x20(%rbx)
je 0x252fb
movq %rax, %r14
movq 0x20cab(%rip), %rdi     # 0x45f78
leaq 0x88cf(%rip), %rsi      # 0x2dba3
callq 0xb5e0
movq %rax, %rdi
movq %r14, %rsi
callq 0xb470
leaq 0x5e34(%rip), %rsi      # 0x2b11f
movq %rax, %rdi
callq 0xb5e0
movq %rax, %rdi
callq 0xb320
movq 0x8(%rbx), %r14
pushq $0x1
popq %rbp
leaq 0x88c6(%rip), %r12      # 0x2dbcf
leaq 0x8482(%rip), %r13      # 0x2d792
cmpq (%rbx), %r14
je 0x25375
movq 0x20c5c(%rip), %rdi     # 0x45f78
leaq 0x88aa(%rip), %rsi      # 0x2dbcd
callq 0xb5e0
movq %rax, %rdi
movl %ebp, %esi
callq 0xbb70
movq %rax, %rdi
movq %r12, %rsi
callq 0xb5e0
leaq -0x40(%r14), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xb570
movq %rax, %rdi
movq %r13, %rsi
callq 0xb5e0
addq $-0x20, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xb570
movq %rax, %rdi
callq 0xb320
incl %ebp
movq %r15, %r14
jmp 0x25310
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x253cb
movq 0x21939(%rip), %rax     # 0x46cd8
subq 0x2192a(%rip), %rax     # 0x46cd0
sarq $0x6, %rax
cmpq %rdx, %rax
jae 0x253d1
leaq 0x1(%rax), %rcx
cmpq %rdx, %rcx
ja 0x253cb
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
sarq $0x6, %rcx
addq %rax, %rcx
cmpq %rdx, %rcx
jae 0x253ff
movb $0x0, 0x40(%rbx)
jmp 0x253f4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x25078
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25056
movq %r14, %rdi
callq 0x17960
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
notq %rax
addq %rdx, %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x25176
jmp 0x253e1
nop
// File: /workspace/github_cpp_makefile_star2_O2/kztomita[P]http-dump/hpack_huffman.cc
// Function: hpack::decode_huffman(unsigned char const*, unsigned long)
std::vector<unsigned char> decode_huffman(const unsigned char* start, std::size_t length) {

  unsigned int offset = 0;
  unsigned int offset_end = length * 8;

  std::vector<unsigned char> decoded;

  auto root = treep->get_root();
  auto node = root;

  while (offset < offset_end) {
    // fetch a bit
    unsigned int bit = (start[offset >> 3] & (0x80 >> (offset & 7))) ? 1 : 0;

    if (bit) {
      if (!node->right) {
        throw std::logic_error("decode error.");
      }
      node = node->right.get();
    } else {
      if (!node->left) {
        throw std::logic_error("decode error.");
      }
      node = node->left.get();
    }
    if (node->value != -1) {
      // found
      if (node->value == 256) {
        break;
      }
      decoded.push_back(node->value);
      node = root;
    }

    offset++;
  }

  return decoded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
shll $0x3, %r14d
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x211cc(%rip), %rax     # 0x46cf0
movq (%rax), %r13
xorl %ebp, %ebp
leaq 0x7(%rsp), %r12
movq %r13, %rax
cmpl %ebp, %r14d
je 0x25b84
movl %ebp, %ecx
shrl $0x3, %ecx
movzbl (%r15,%rcx), %edx
movl %ebp, %ecx
andb $0x7, %cl
shll %cl, %edx
testb %dl, %dl
jns 0x25b56
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x25b5e
jmp 0x25b96
movq (%rax), %rax
testq %rax, %rax
je 0x25bb2
movl 0x10(%rax), %ecx
cmpl $-0x1, %ecx
je 0x25b80
cmpl $0x100, %ecx            # imm = 0x100
je 0x25b84
movb %cl, 0x7(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23736
movq %r13, %rax
incl %ebp
jmp 0x25b31
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb330
movq %rax, %r14
leaq 0x802a(%rip), %rsi      # 0x2dbd2
movq %rax, %rdi
callq 0xb9b0
jmp 0x25bcc
pushq $0x10
popq %rdi
callq 0xb330
movq %rax, %r14
leaq 0x800e(%rip), %rsi      # 0x2dbd2
movq %rax, %rdi
callq 0xb9b0
movq 0x203dd(%rip), %rsi     # 0x45fb0
movq 0x2038e(%rip), %rdx     # 0x45f68
movq %r14, %rdi
callq 0xbb50
jmp 0x25be4
movq %rax, %r15
movq %r14, %rdi
callq 0xb4d0
jmp 0x25bf6
jmp 0x25bf3
movq %rax, %r15
movq %rbx, %rdi
callq 0xf41c
movq %r15, %rdi
callq 0xbba0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r15
leaq 0x1f76a(%rip), %rax     # 0x454b8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0xd494
leaq 0x18(%r15), %r14
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x26132
movb %r12b, 0x30(%r15)
leaq 0x38(%r15), %r12
leaq 0x8709(%rip), %rsi      # 0x2e484
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0xd416
andq $0x0, 0x58(%r15)
addq $0x58, %r15
movq %r14, %rdi
callq 0x2644c
movq (%r14), %r13
testb %bpl, %bpl
je 0x25db3
leaq 0x86e6(%rip), %rsi      # 0x2e48e
pushq $0x3
popq %rdx
movq %r13, %rdi
callq 0xbbb0
cmpq $0x0, 0x20e15(%rip)     # 0x46bd0
je 0x25dcc
leaq 0x86(%rip), %rsi        # 0x25e4a
movq %r13, %rdi
callq 0xba30
movl $0x1a0, %edi            # imm = 0x1A0
callq 0xb5f0
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x26484
movq %r15, %rdi
movq %rbp, %rsi
callq 0x27c5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movl $0x1a0, %esi            # imm = 0x1A0
movq %rbp, %rdi
callq 0xb610
jmp 0x25e22
jmp 0x25e1f
movq %rax, %r13
jmp 0x25e32
movq %rax, %r13
jmp 0x25e3a
movq %rax, %r13
movq %r15, %rdi
callq 0x1ef9c
movq %r12, %rdi
callq 0xb2f0
movq %r14, %rdi
callq 0x1efb6
movq %rbx, %rdi
callq 0xd578
movq %r13, %rdi
callq 0xbba0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq 0x20d72(%rip), %rsi     # 0x46bd0
leaq 0x8(%rsp), %r14
pushq $0x11
popq %rdx
movq %r14, %rdi
callq 0xb6b0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x25ea6
movq 0x2015d(%rip), %rdi     # 0x45fe0
leaq 0x8635(%rip), %rsi      # 0x2e4bf
callq 0xb5e0
movq 0x20d3a(%rip), %rsi     # 0x46bd0
movq %rax, %rdi
callq 0xb5e0
movq %rax, %rdi
callq 0xb320
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xb5e0
movq %rax, %rdi
callq 0xb320
leaq 0x8(%rsp), %rdi
callq 0xb990
leaq 0x8(%rsp), %rdi
callq 0xba00
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xba00
movq %rbx, %rdi
callq 0xbba0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %r14
leaq 0x2c(%rsp), %r15
movq %r15, %rdi
callq 0x27184
movq %r14, %rdi
movq %r15, %rsi
callq 0x25fd4
cmpb $0x1, 0x30(%rbx)
jne 0x25f79
movq 0x38(%rbx), %rcx
movq 0x58(%rbx), %rax
movq 0x50(%rax), %rdi
leaq 0x38(%rbx), %r14
pushq $0x37
popq %rsi
xorl %edx, %edx
callq 0xb280
movq 0x58(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x264f6
movq 0x58(%rbx), %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xb920
movq %r15, %rdi
movq %r12, %rsi
callq 0x2652e
leaq 0x8(%rsp), %rdi
callq 0xb2f0
movq 0x58(%rbx), %rdi
xorl %esi, %esi
callq 0x265a2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb2f0
movq %rbx, %rdi
callq 0xbba0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
setne %al
cmpq %rdx, %rsi
seta %cl
andb %al, %cl
cmovneq %rdx, %rbx
movq %rdi, %r14
leaq (%rdi,%rbx), %r15
pushq $0x10
popq %r12
movzbl %cl, %ebp
leaq -0x10(%r12), %rax
cmpq %rbx, %rax
jae 0x2a3b6
leaq (%r14,%r12), %rdi
addq $-0x10, %rdi
cmpq %rbx, %r12
jbe 0x2a3a5
movq %r15, %rsi
movl %ebp, %edx
jmp 0x2a3ab
leaq (%r14,%r12), %rsi
xorl %edx, %edx
callq 0x2a3bf
addq $0x10, %r12
jmp 0x2a387
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kztomita[P]http-dump/dump.cc
// Function: (anonymous namespace)::out_line(char const*, char const*, bool)
void out_line(const char* start, const char* end, bool snipped) {
  std::ostringstream octets;
  std::string chars;

  octets << std::hex;
  for (auto p = start ; p < end ; p++) {
    octets << std::setw(2) << std::setfill('0') << (static_cast<int>(*p) & 0xff) << " ";

    if (*p >= 0x20 && *p <= 0x7e) {
      chars += *p;
    } else {
      chars += ".";
    }
  }
  if (snipped) {
    octets << "snipped...";
  }

  std::ostringstream line;
  line << std::left << std::setw(16*3 + 2) << octets.str() << chars;

  std::cout << line.str() <<  std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x338, %rsp            # imm = 0x338
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1c0(%rsp), %r12
movq %r12, %rdi
callq 0xb8f0
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x1d8(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x1d8(%rsp,%rax)
pushq $0x30
popq %rbp
leaq 0x3371(%rip), %r13      # 0x2d792
leaq 0x28(%rsp), %rbx
cmpq %r14, %r15
jae 0x2a490
movq 0x1c0(%rsp), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x1d0(%rsp,%rax)
movq %r12, %rdi
movl %ebp, %esi
callq 0xba80
movzbl (%r15), %esi
movq %rax, %rdi
callq 0xbb70
movq %rax, %rdi
movq %r13, %rsi
callq 0xb5e0
movb (%r15), %al
leal -0x7f(%rax), %ecx
cmpb $-0x5f, %cl
jae 0x2a480
movq %rbx, %rdi
leaq 0x2b01(%rip), %rsi      # 0x2cf7a
callq 0xbce0
jmp 0x2a48b
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb550
incq %r15
jmp 0x2a426
cmpb $0x0, 0x4(%rsp)
je 0x2a4ab
leaq 0x47b2(%rip), %rsi      # 0x2ec50
leaq 0x1c0(%rsp), %rdi
callq 0xb5e0
leaq 0x48(%rsp), %rdi
callq 0xb8f0
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rcx
movl $0xffffff4f, %edx       # imm = 0xFFFFFF4F
andl 0x60(%rsp,%rcx), %edx
orl $0x20, %edx
movl %edx, 0x60(%rsp,%rcx)
movq -0x18(%rax), %rax
movq $0x32, 0x58(%rsp,%rax)
leaq 0x1c8(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xbaa0
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb570
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xb570
leaq 0x8(%rsp), %rdi
callq 0xb2f0
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xbaa0
movq 0x1ba4f(%rip), %rdi     # 0x45f78
leaq 0x8(%rsp), %rsi
callq 0xb570
movq %rax, %rdi
callq 0xb320
leaq 0x8(%rsp), %rdi
callq 0xb2f0
leaq 0x48(%rsp), %rdi
callq 0xb120
leaq 0x28(%rsp), %rdi
callq 0xb2f0
leaq 0x1c0(%rsp), %rdi
callq 0xb120
addq $0x338, %rsp            # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a59e
jmp 0x2a57c
movq %rax, %rbx
jmp 0x2a592
jmp 0x2a59e
jmp 0x2a585
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb2f0
leaq 0x48(%rsp), %rdi
callq 0xb120
jmp 0x2a5a1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb2f0
leaq 0x1c0(%rsp), %rdi
callq 0xb120
movq %rbx, %rdi
callq 0xbba0
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyensure_buffer_stack()
void yyFlexLexer::yyensure_buffer_stack(void)
{
	yy_size_t num_to_alloc;
    
	if (!(yy_buffer_stack)) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		(yy_buffer_stack_max) = num_to_alloc;
		(yy_buffer_stack_top) = 0;
		return;
	}

	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = (yy_buffer_stack_max) + grow_size;
		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
								((yy_buffer_stack),
								num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
		(yy_buffer_stack_max) = num_to_alloc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x288(%rdi), %rdi
testq %rdi, %rdi
je 0x3e06
movq 0x280(%rbx), %r14
leaq -0x1(%r14), %rax
cmpq %rax, 0x278(%rbx)
jb 0x3e48
leaq 0x40(,%r14,8), %rsi
addq $0x8, %r14
callq 0x3330
movq %rax, 0x288(%rbx)
testq %rax, %rax
jne 0x3de0
movq (%rbx), %rax
leaq 0x6a40(%rip), %rsi      # 0xa813
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x288(%rbx), %rax
movq 0x280(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax,%rcx,8)
movups %xmm0, 0x20(%rax,%rcx,8)
movups %xmm0, 0x10(%rax,%rcx,8)
movups %xmm0, (%rax,%rcx,8)
movq %r14, 0x280(%rbx)
jmp 0x3e48
pushq $0x8
popq %rdi
callq 0x32a0
movq %rax, 0x288(%rbx)
testq %rax, %rax
jne 0x3e31
movq (%rbx), %rax
leaq 0x69ef(%rip), %rsi      # 0xa813
movq %rbx, %rdi
callq *0x70(%rax)
movq 0x288(%rbx), %rax
andq $0x0, (%rax)
movq $0x1, 0x280(%rbx)
andq $0x0, 0x278(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq %esi, %rax
addq $-0x63, %rax
cmpq $-0x60, %rax
jb 0x3f87
movq 0x260(%rdi), %rax
movl %esi, 0x290(%rdi)
movq %rax, 0x298(%rdi)
leaq 0x6432(%rip), %rax      # 0xa3c0
leaq 0x62fb(%rip), %rcx      # 0xa290
leaq 0x64f4(%rip), %rdx      # 0xa490
movslq %esi, %rsi
movswq (%rax,%rsi,2), %rdi
movswl 0x2(%rcx,%rdi,2), %r8d
cmpl %r8d, %esi
je 0x3fb5
movswl (%rdx,%rsi,2), %esi
jmp 0x3f9c
leaq 0x65d4(%rip), %rax      # 0xa590
movzwl 0x2(%rax,%rdi,2), %eax
xorl %ecx, %ecx
cmpw $0x63, %ax
cmovnel %eax, %ecx
movswl %cx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb4c8(%rip), %rax      # 0xf8d8
movq %rax, (%rdi)
movq 0x2a0(%rdi), %rdi
testq %rdi, %rdi
je 0x4424
callq 0x3270
movq 0x28(%rbx), %rdi
callq 0x3240
movq 0x288(%rbx), %rax
testq %rax, %rax
je 0x4446
movq 0x278(%rbx), %rcx
movq (%rax,%rcx,8), %rsi
jmp 0x4448
xorl %esi, %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movq 0x288(%rbx), %rdi
callq 0x3240
leaq 0x150(%rbx), %rdi
callq 0x30c0
addq $0x30, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3340
movq %rax, %rdi
callq 0x4cc0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rax
movq -0x18(%rax), %rax
xorl %ebx, %ebx
testb $0x7, 0x50(%rdi,%rax)
jne 0x45a1
movq %rdi, %r14
addq $0x30, %r14
movq %r14, %rdi
callq 0x32c0
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x20(%r14,%rax), %eax
testb $0x2, %al
jne 0x45a1
andl $0x1, %eax
negl %eax
orl $0x1, %eax
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyunput(int, char*)
void yyFlexLexer::yyunput( int c, char* yy_bp)
{
	char *yy_cp;
    
    yy_cp = (yy_c_buf_p);

	/* undo effects of setting up yytext */
	*yy_cp = (yy_hold_char);

	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		int number_to_move = (yy_n_chars) + 2;
		char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
		char *source =
				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
			*--dest = *--source;

		yy_cp += (int) (dest - source);
		yy_bp += (int) (dest - source);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
			(yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}

	*--yy_cp = (char) c;

    if ( c == '\n' ){
        --yylineno;
    }

	(yytext_ptr) = yy_bp;
	(yy_hold_char) = *yy_cp;
	(yy_c_buf_p) = yy_cp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x260(%rdi), %r12
movb 0x258(%rdi), %al
movb %al, (%r12)
movq 0x278(%rdi), %rax
movq 0x288(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rax
leaq 0x2(%rax), %rdx
cmpq %rdx, %r12
jae 0x4690
movslq 0x25c(%rbx), %rdx
movslq 0x18(%rcx), %rdi
addq %rax, %rdx
addq $0x2, %rdx
leaq (%rax,%rdi), %rsi
addq $0x2, %rsi
addq %rax, %rdi
incq %rdi
movq %rdx, %r8
cmpq %rax, %r8
jbe 0x4660
movb -0x1(%r8), %al
decq %r8
movb %al, (%rdi)
movq 0x278(%rbx), %rax
movq 0x288(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rax
decq %rsi
decq %rdi
decq %rdx
jmp 0x4631
subl %edx, %esi
movslq %esi, %rdx
addq %rdx, %r12
addq %rdx, %r14
movl 0x18(%rcx), %edx
movl %edx, 0x25c(%rbx)
movl %edx, 0x1c(%rcx)
addq $0x2, %rax
cmpq %rax, %r12
jae 0x4690
movq (%rbx), %rax
leaq 0x613d(%rip), %rsi      # 0xa7c7
movq %rbx, %rdi
callq *0x70(%rax)
movb %r15b, -0x1(%r12)
decq %r12
cmpl $0xa, %r15d
jne 0x46a1
decl 0x14(%rbx)
movq %r14, 0x8(%rbx)
movb (%r12), %al
movb %al, 0x258(%rbx)
movq %r12, 0x260(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/lex.yy.cc
// Function: yyFlexLexer::yyinput()
int yyFlexLexer::yyinput()
{
	int c;
    
	*(yy_c_buf_p) = (yy_hold_char);

	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
			/* This was really a NUL. */
			*(yy_c_buf_p) = '\0';

		else
			{ /* need more input */
			int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
			++(yy_c_buf_p);

			switch ( yy_get_next_buffer(  ) )
				{
				case EOB_ACT_LAST_MATCH:
					/* This happens because yy_g_n_b()
					 * sees that we've accumulated a
					 * token and flags that we need to
					 * try matching the token before
					 * proceeding.  But for input(),
					 * there's no matching to consider.
					 * So convert the EOB_ACT_LAST_MATCH
					 * to EOB_ACT_END_OF_FILE.
					 */

					/* Reset buffer status. */
					yyrestart( yyin );

					/*FALLTHROUGH*/

				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap(  ) )
						return 0;

					if ( ! (yy_did_buffer_switch_on_eof) )
						YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput();
#else
					return input();
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					(yy_c_buf_p) = (yytext_ptr) + offset;
					break;
				}
			}
		}

	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
	*(yy_c_buf_p) = '\0';	/* preserve yytext */
	(yy_hold_char) = *++(yy_c_buf_p);

	if ( c == '\n' )
		
    yylineno++;
;

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movb 0x258(%rbx), %al
movq 0x260(%rbx), %rcx
movb %al, (%rcx)
movq 0x260(%rbx), %r15
movb (%r15), %al
testb %al, %al
jne 0x4792
movq 0x278(%rbx), %rax
movq 0x288(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movslq 0x25c(%rbx), %rcx
addq 0x8(%rax), %rcx
cmpq %rcx, %r15
jb 0x476d
movq 0x8(%rbx), %r12
leaq 0x1(%r15), %rax
movq %rax, 0x260(%rbx)
movq %rbx, %rdi
callq 0x3fd0
cmpl $0x1, %eax
je 0x4742
cmpl $0x2, %eax
jne 0x477e
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
testl %eax, %eax
jne 0x477a
cmpl $0x0, 0x270(%rbx)
jne 0x46d2
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
jmp 0x46d2
movb $0x0, (%r15)
movq 0x260(%rbx), %r15
jmp 0x478f
xorl %eax, %eax
jmp 0x47c0
subl %r12d, %r15d
movslq %r15d, %r15
addq 0x8(%rbx), %r15
movq %r15, 0x260(%rbx)
movb (%r15), %al
movb $0x0, (%r15)
movq 0x260(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x260(%rbx)
movb 0x1(%rcx), %cl
movb %cl, 0x258(%rbx)
cmpb $0xa, %al
jne 0x47bd
incl 0x14(%rbx)
pushq $0xa
popq %rax
jmp 0x47c0
movzbl %al, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x288(%rdi), %rax
testq %rax, %rax
je 0x47f1
movq 0x278(%rbx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4829
movq %rbx, %rdi
callq 0x3d7e
leaq 0x30(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x4000, %edx           # imm = 0x4000
callq *0x20(%rax)
movq 0x278(%rbx), %rcx
movq 0x288(%rbx), %rdx
movq %rax, (%rdx,%rcx,8)
movq 0x288(%rbx), %rax
testq %rax, %rax
je 0x482f
movq (%rax,%rcx,8), %rsi
jmp 0x4831
xorl %esi, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4848
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3e4e
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3040
movq %rax, %r14
movl (%rax), %r13d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4a60
movq (%r12), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r12,%rax), %rax
movq %rax, (%rbx)
movl $0x1, 0x34(%rbx)
movq 0x288(%r15), %rax
testq %rax, %rax
je 0x48a8
movq 0x278(%r15), %rcx
movq (%rax,%rcx,8), %rax
jmp 0x48aa
xorl %eax, %eax
cmpq %rbx, %rax
je 0x48b7
movq $0x1, 0x2c(%rbx)
andl $0x0, 0x24(%rbx)
movl %r13d, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0x32a0
movq %rax, %r15
testq %rax, %rax
jne 0x49a4
movq (%r14), %rax
leaq 0x5e49(%rip), %rsi      # 0xa7e7
movq %r14, %rdi
callq *0x70(%rax)
movl %r12d, 0x18(%r15)
addl $0x2, %r12d
movslq %r12d, %rdi
callq 0x32a0
movq %rax, 0x8(%r15)
testq %rax, %rax
jne 0x49cd
movq (%r14), %rax
leaq 0x5e20(%rip), %rsi      # 0xa7e7
movq %r14, %rdi
callq *0x70(%rax)
movl $0x1, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4848
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x4a2f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x288(%rdi), %rax
testq %rax, %rax
je 0x4a30
movq 0x278(%rdi), %rcx
movq (%rax,%rcx,8), %rcx
jmp 0x4a32
retq
xorl %ecx, %ecx
cmpq %rbx, %rcx
jne 0x4a43
movq 0x278(%rdi), %rcx
andq $0x0, (%rax,%rcx,8)
cmpl $0x0, 0x20(%rbx)
je 0x4a52
movq 0x8(%rbx), %rdi
callq 0x3240
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movslq 0x20(%rdi), %rax
cmpl %eax, 0x1c(%rdi)
jl 0x4c18
leaq 0x19(%rax), %rcx
movl %ecx, 0x20(%rbx)
leaq 0x64(,%rax,4), %rsi
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4bf7
callq 0x3330
jmp 0x4bff
movq %rsi, %rdi
callq 0x32a0
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0x4c18
movq (%rbx), %rax
leaq 0x5c32(%rip), %rsi      # 0xa844
movq %rbx, %rdi
callq *0x70(%rax)
movl 0x26c(%rbx), %eax
decl %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movq 0x28(%rbx), %rcx
movslq 0x1c(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x1c(%rbx)
movl %eax, (%rcx,%rdx,4)
leal 0x1(%r14,%r14), %eax
movl %eax, 0x26c(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/devaigergely81[P]flex-bison-example/while.cc
// Function: yylex(yy::parser::value_type*, yy::location*)
int yylex(yy::parser::semantic_type* yylval, yy::parser::location_type* yylloc) {
    yylloc->begin.line = lexer->lineno();
    int token = lexer->yylex();
    if(token == yy::parser::token::ID || token == yy::parser::token::NUM) {
        yylval->build(std::string(lexer->YYText()));
    }
    return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0xb539(%rip), %rdi      # 0x10220
movl 0x14(%rdi), %eax
movl %eax, 0x8(%rsi)
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebx
leal -0x115(%rbx), %eax
cmpl $0x1, %eax
ja 0x4d2f
movq 0xb519(%rip), %rax      # 0x10220
movq 0x8(%rax), %rsi
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x4f92
movq %r14, %rdi
movq %r15, %rsi
callq 0x32b0
leaq -0x40(%rbp), %rdi
callq 0x3110
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3370