LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ef-gy[P]libefgy/src/test-case/matrix.cpp
// Function: testConstruction(std::ostream&)
bool testConstruction(std::ostream &log) {
  matrix<int, 3, 4> m;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 4; k++) {
      m[i][k] = i * k;
    }
  }

  matrix<int, 3, 4> m2(m);

  bool allCorrect = true;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 4; k++) {
      allCorrect &= (m2[i][k] == (i * k));
    }
  }

  if (!allCorrect) {
    log << "Actual and expected value in result of copy constructor are "
           "different";
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x3, -0x44(%rbp)
jge 0x5e7f
movl $0x0, -0x48(%rbp)
cmpl $0x4, -0x48(%rbp)
jge 0x5e72
movl -0x44(%rbp), %eax
imull -0x48(%rbp), %eax
movl %eax, -0x88(%rbp)
movslq -0x44(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x74b0
movq %rax, %rdi
movslq -0x48(%rbp), %rsi
callq 0x74e0
movl -0x88(%rbp), %ecx
movl %ecx, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x5e33
jmp 0x5e74
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5e26
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x30, %edx
callq 0x5310
movb $0x1, -0x79(%rbp)
movl $0x0, -0x80(%rbp)
cmpl $0x3, -0x80(%rbp)
jge 0x5f1a
movl $0x0, -0x84(%rbp)
cmpl $0x4, -0x84(%rbp)
jge 0x5f0d
movslq -0x80(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x74b0
movq %rax, %rdi
movslq -0x84(%rbp), %rsi
callq 0x74e0
movl (%rax), %eax
movl -0x80(%rbp), %ecx
imull -0x84(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x79(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x79(%rbp)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x5eac
jmp 0x5f0f
movl -0x80(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
jmp 0x5e9c
testb $0x1, -0x79(%rbp)
jne 0x5f36
movq -0x10(%rbp), %rdi
leaq 0x2f29b(%rip), %rsi     # 0x351c6
callq 0x5390
movb $0x0, -0x1(%rbp)
jmp 0x5f3a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ef-gy[P]libefgy/src/test-case/matrix.cpp
// Function: testAssignment(std::ostream&)
bool testAssignment(std::ostream &log) {
  matrix<int, 3, 4> m;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 4; k++) {
      m[i][k] = i * k;
    }
  }

  matrix<int, 3, 4> m2 = m;

  bool allCorrect = true;
  for (int i = 0; i < 3; i++) {
    for (int k = 0; k < 3; k++) {
      allCorrect &= (m2[i][k] == m[i][k]);
    }
  }

  if (!allCorrect) {
    log << "Values were not copied correctly during assignment.";
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x3, -0x44(%rbp)
jge 0x5fbf
movl $0x0, -0x48(%rbp)
cmpl $0x4, -0x48(%rbp)
jge 0x5fb2
movl -0x44(%rbp), %eax
imull -0x48(%rbp), %eax
movl %eax, -0x88(%rbp)
movslq -0x44(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x74b0
movq %rax, %rdi
movslq -0x48(%rbp), %rsi
callq 0x74e0
movl -0x88(%rbp), %ecx
movl %ecx, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x5f73
jmp 0x5fb4
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5f66
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x30, %edx
callq 0x5310
movb $0x1, -0x79(%rbp)
movl $0x0, -0x80(%rbp)
cmpl $0x3, -0x80(%rbp)
jge 0x6085
movl $0x0, -0x84(%rbp)
cmpl $0x3, -0x84(%rbp)
jge 0x6075
movslq -0x80(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x74b0
movq %rax, %rdi
movslq -0x84(%rbp), %rsi
callq 0x74e0
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
movslq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x74b0
movq %rax, %rdi
movslq -0x84(%rbp), %rsi
callq 0x74e0
movq %rax, %rcx
movl -0x8c(%rbp), %eax
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x79(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x79(%rbp)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x5ff0
jmp 0x6077
movl -0x80(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
jmp 0x5fdc
testb $0x1, -0x79(%rbp)
jne 0x60a1
movq -0x10(%rbp), %rdi
leaq 0x2f176(%rip), %rsi     # 0x3520c
callq 0x5390
movb $0x0, -0x1(%rbp)
jmp 0x60a5
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: efgy::math::matrix<int, 3ul, 4ul> efgy::math::operator+<int, 3ul, 4ul>(efgy::math::matrix<int, 3ul, 4ul> const&, efgy::math::matrix<int, 3ul, 4ul> const&)
matrix<Q, n, m> operator+(const matrix<Q, n, m> &a, const matrix<Q, n, m> &b) {
  matrix<Q, n, m> r;

  for (std::size_t i = 0; i < n; i++) {
    for (std::size_t j = 0; j < m; j++) {
      r[i][j] = a[i][j] + b[i][j];
    }
  }

  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0x75cb
movq $0x0, -0x20(%rbp)
cmpq $0x4, -0x20(%rbp)
jae 0x75b8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33c60
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x33c90
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33c60
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x33c90
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl -0x38(%rbp), %eax
addl (%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rsi
callq 0x74b0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x74e0
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7543
jmp 0x75ba
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7530
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Konano[P]Artificial-Intelligence-Input-Method/main.cpp
// Function: main
int main()
{
	ReadData();

	BuildTree();

	#ifdef __DEBUG
	puts("�������ݵ��룡");
	#endif

	ifstream fin("input.txt");
	ofstream fout("output.txt");

	string str; int tot = 0;
	while (getline(fin, str) && str != "")
	{
		printf("Now: %d\n", ++tot);
		fout << Translate(str) << endl;
	}
	return 0;
}

// Assembly:
subq $0x4a8, %rsp            # imm = 0x4A8
movl $0x0, 0x4a4(%rsp)
callq 0x2db0
callq 0x30a0
leaq 0xa625(%rip), %rdi      # 0xd018
callq 0x2320
leaq 0xa628(%rip), %rsi      # 0xd027
leaq 0x298(%rsp), %rdi
movl $0x8, %edx
callq 0x2390
leaq 0xa619(%rip), %rsi      # 0xd031
leaq 0x98(%rsp), %rdi
movl $0x10, %edx
callq 0x2240
jmp 0x2a2c
leaq 0x68(%rsp), %rdi
callq 0x22d0
movl $0x0, 0x64(%rsp)
leaq 0x298(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2080
movq %rax, 0x18(%rsp)
jmp 0x2a57
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2290
movb %al, 0x17(%rsp)
jmp 0x2a71
movb 0x17(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x16(%rsp)
jne 0x2a82
jmp 0x2aa3
leaq 0xa5bb(%rip), %rsi      # 0xd044
leaq 0x68(%rsp), %rdi
callq 0x30d0
movb %al, 0x15(%rsp)
jmp 0x2a99
movb 0x15(%rsp), %al
movb %al, 0x16(%rsp)
jmp 0x2aa3
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0x2ab0
jmp 0x2ba0
movl 0x64(%rsp), %esi
incl %esi
movl %esi, 0x64(%rsp)
leaq 0xa57b(%rip), %rdi      # 0xd03c
xorl %eax, %eax
callq 0x2050
jmp 0x2aca
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x20e0
jmp 0x2adb
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3100
jmp 0x2aec
leaq 0x98(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x21c0
movq %rax, 0x8(%rsp)
jmp 0x2b05
movq 0x8(%rsp), %rdi
movq 0x104bf(%rip), %rsi     # 0x12fd0
callq 0x2210
jmp 0x2b18
leaq 0x40(%rsp), %rdi
callq 0x2130
leaq 0x20(%rsp), %rdi
callq 0x2130
jmp 0x2a3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x2bf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x2bde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x2b94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2130
leaq 0x20(%rsp), %rdi
callq 0x2130
jmp 0x2bde
movl $0x0, 0x4a4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2130
leaq 0x98(%rsp), %rdi
callq 0x22f0
leaq 0x298(%rsp), %rdi
callq 0x2090
movl 0x4a4(%rsp), %eax
addq $0x4a8, %rsp            # imm = 0x4A8
retq
leaq 0x68(%rsp), %rdi
callq 0x2130
leaq 0x98(%rsp), %rdi
callq 0x22f0
leaq 0x298(%rsp), %rdi
callq 0x2090
movq 0x90(%rsp), %rdi
callq 0x2360
nop
// File: Konano[P]Artificial-Intelligence-Input-Method/main.cpp
// Function: Insert(int)
inline void Insert(int id)
{
	int now = 0;
	int L = (int)Word_pinyin[id].size();
	for(int i = 0; i < L; i++)
	{
		if (Tree[now].children[Word_pinyin[id][i]] == 0)
			Tree[now].children[Word_pinyin[id][i]] = ++TreeTotal;
		now = Tree[now].children[Word_pinyin[id][i]];
	}
	Tree[now].wd.push_back(id);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movslq 0x34(%rsp), %rax
leaq 0x2dd4514(%rip), %rdi   # 0x2dddcc0
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x81d0
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x98cc
movslq 0x30(%rsp), %rcx
leaq 0x59b2cc2(%rip), %rax   # 0x59bc4a0
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movslq 0x34(%rsp), %rax
leaq 0x2dd44ca(%rip), %rdi   # 0x2dddcc0
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x99f0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x9900
cmpl $0x0, (%rax)
jne 0x9874
movl 0xc0b1f81(%rip), %eax   # 0xc0bb7a0
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl %eax, 0xc0b1f74(%rip)   # 0xc0bb7a0
movslq 0x30(%rsp), %rcx
leaq 0x59b2c68(%rip), %rax   # 0x59bc4a0
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movslq 0x34(%rsp), %rax
leaq 0x2dd4470(%rip), %rdi   # 0x2dddcc0
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x99f0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x9900
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movslq 0x30(%rsp), %rcx
leaq 0x59b2c20(%rip), %rax   # 0x59bc4a0
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movslq 0x34(%rsp), %rax
leaq 0x2dd4428(%rip), %rdi   # 0x2dddcc0
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x99f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x9900
movl (%rax), %eax
movl %eax, 0x30(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x97c4
movslq 0x30(%rsp), %rax
leaq 0x59b2bc8(%rip), %rdi   # 0x59bc4a0
imulq $0x48, %rax, %rax
addq %rax, %rdi
addq $0x30, %rdi
leaq 0x34(%rsp), %rsi
callq 0x9a10
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kztomita[P]http-dump/main.cc
// Function: usage(char const*)
void usage(const char* message = nullptr) {
  if (message) {
    std::cerr << message << std::endl << std::endl;
  }
  std::cerr << "Usage:" << std::endl;
  std::cerr << "http-client <options> <url>" << std::endl << std::endl;
  std::cerr << "-v:       verbose mode" << std::endl;
  std::cerr << "-h:       show this help" << std::endl;
  std::cerr << "--http2:  use http/2 (https only)" << std::endl;
  std::cerr << "--keylog <filename>:  TLS keylog file" << std::endl;
  std::cerr << "-H:       add header (Ex.-H \"X-Foo: bar\")" << std::endl;
  std::cerr << "-k:       skip certificate verification" << std::endl;

  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf791
movq -0x8(%rbp), %rsi
movq 0x9d83a(%rip), %rdi     # 0xacfa8
callq 0xd860
movq %rax, %rdi
movq 0x9d81b(%rip), %rsi     # 0xacf98
callq 0xde80
movq %rax, %rdi
movq 0x9d80c(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x9d810(%rip), %rdi     # 0xacfa8
leaq 0x638de(%rip), %rsi     # 0x7307d
callq 0xd860
movq %rax, %rdi
movq 0x9d7ea(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x9d7ee(%rip), %rdi     # 0xacfa8
leaq 0x638c3(%rip), %rsi     # 0x73084
callq 0xd860
movq %rax, %rdi
movq 0x9d7c8(%rip), %rsi     # 0xacf98
callq 0xde80
movq %rax, %rdi
movq 0x9d7b9(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x9d7bd(%rip), %rdi     # 0xacfa8
leaq 0x638ae(%rip), %rsi     # 0x730a0
callq 0xd860
movq %rax, %rdi
movq 0x9d797(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x9d79b(%rip), %rdi     # 0xacfa8
leaq 0x638a3(%rip), %rsi     # 0x730b7
callq 0xd860
movq %rax, %rdi
movq 0x9d775(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x9d779(%rip), %rdi     # 0xacfa8
leaq 0x6389a(%rip), %rsi     # 0x730d0
callq 0xd860
movq %rax, %rdi
movq 0x9d753(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x9d757(%rip), %rdi     # 0xacfa8
leaq 0x6389a(%rip), %rsi     # 0x730f2
callq 0xd860
movq %rax, %rdi
movq 0x9d731(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x9d735(%rip), %rdi     # 0xacfa8
leaq 0x6389e(%rip), %rsi     # 0x73118
callq 0xd860
movq %rax, %rdi
movq 0x9d70f(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x9d713(%rip), %rdi     # 0xacfa8
leaq 0x638a6(%rip), %rsi     # 0x73142
callq 0xd860
movq %rax, %rdi
movq 0x9d6ed(%rip), %rsi     # 0xacf98
callq 0xde80
movl $0x1, %edi
callq 0xd9c0
nopw (%rax,%rax)
// File: kztomita[P]http-dump/http_header.cc
// Function: create_http_header_from_header_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
http_header_ptr create_http_header_from_header_line(const std::string& line) {
  auto h = create_http_header_from_header_line_or_null(line);
  if (!h) {
    std::ostringstream os;
    os << "invalid format (" << line << ")";
    throw std::invalid_argument(os.str());
  }
  return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4d560
movq -0x1d0(%rbp), %rdi
callq 0x10ae0
testb $0x1, %al
jne 0x4daa9
leaq -0x190(%rbp), %rdi
callq 0xdd60
jmp 0x4d973
leaq 0x276ff(%rip), %rsi     # 0x75079
leaq -0x190(%rbp), %rdi
callq 0xd860
movq %rax, -0x1e0(%rbp)
jmp 0x4d98f
movq -0x1e0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd480
movq %rax, -0x1e8(%rbp)
jmp 0x4d9a8
movq -0x1e8(%rbp), %rdi
leaq 0x2578a(%rip), %rsi     # 0x73140
callq 0xd860
jmp 0x4d9bd
movb $0x1, -0x1c1(%rbp)
movl $0x10, %edi
callq 0xd580
movq %rax, -0x1f0(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xe0c0
jmp 0x4d9ea
movq -0x1f0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xd870
jmp 0x4d9ff
movq -0x1f0(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
movq 0x5f514(%rip), %rsi     # 0xacf28
movq 0x5f505(%rip), %rdx     # 0xacf20
callq 0xd970
jmp 0x4dae7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x4dacf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x4da9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x4da82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xdac0
testb $0x1, -0x1c1(%rbp)
jne 0x4da8d
jmp 0x4da99
movq -0x1f0(%rbp), %rdi
callq 0xdc70
jmp 0x4da9b
leaq -0x190(%rbp), %rdi
callq 0xdcb0
jmp 0x4dacf
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4dabf
movq -0x1d0(%rbp), %rdi
callq 0x10b60
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x10b60
movq -0x198(%rbp), %rdi
callq 0xd990
nopw (%rax,%rax)
// File: kztomita[P]http-dump/./string_util_trim.h
// Function: std::basic_string_view<char, std::char_traits<char>> string_util::rtrim<char, std::char_traits<char>>(std::basic_string_view<char, std::char_traits<char>> const&, char const*)
std::basic_string_view<CharT, Traits>
rtrim(const std::basic_string_view<CharT, Traits>& s, const CharT* chars) {
  using _SView = std::basic_string_view<CharT, Traits>;

  auto pos = s.find_last_not_of(chars);
  if (pos == _SView::npos) {
    return s;
  }

  return s.substr(0, pos + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq $-0x1, %rdx
callq 0x4e0a0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x4e004
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4e021
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x4dbd0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nop
// File: kztomita[P]http-dump/./string_util_trim.h
// Function: std::basic_string_view<char, std::char_traits<char>> string_util::ltrim<char, std::char_traits<char>>(std::basic_string_view<char, std::char_traits<char>> const&, char const*)
std::basic_string_view<CharT, Traits>
ltrim(const std::basic_string_view<CharT, Traits>& s, const CharT* chars) {
  using _SView = std::basic_string_view<CharT, Traits>;

  auto pos = s.find_first_not_of(chars);
  if (pos == _SView::npos) {
    return s;
  }

  return s.substr(pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4e280
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x4e071
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4e08d
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq $-0x1, %rdx
callq 0x4dbd0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kztomita[P]http-dump/./string_util_trim.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> string_util::rtrim<char, std::char_traits<char>, std::allocator<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
std::basic_string<CharT, Traits, Alloc>
rtrim(const std::basic_string<CharT, Traits, Alloc>& s, const CharT* chars) {
  using _String = std::basic_string<CharT, Traits, Alloc>;

  auto pos = s.find_last_not_of(chars);
  if (pos == _String::npos) {
    return s;
  }

  return s.substr(0, pos + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $-0x1, %rdx
callq 0xdbe0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x4e3bd
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd1e0
jmp 0x4e3d6
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xde20
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: kztomita[P]http-dump/./string_util_trim.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> string_util::ltrim<char, std::char_traits<char>, std::allocator<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
std::basic_string<CharT, Traits, Alloc>
ltrim(const std::basic_string<CharT, Traits, Alloc>& s, const CharT* chars) {
  using _String = std::basic_string<CharT, Traits, Alloc>;

  auto pos = s.find_first_not_of(chars);
  if (pos == _String::npos) {
    return s;
  }

  return s.substr(pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xdc80
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x4e42a
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd1e0
jmp 0x4e442
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq $-0x1, %rcx
callq 0xde20
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: kztomita[P]http-dump/http_response.cc
// Function: dump(http_response const&)
void dump(const http_response& r) {
  std::cout << "HTTP Response" << std::endl;
  std::cout << "Status " << r.code_ << std::endl;
  std::cout << "Headers" << std::endl;
  for (const auto& h : r.headers_) {
    std::cout << *h << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5e99d(%rip), %rdi     # 0xacf40
leaq 0x26b2b(%rip), %rsi     # 0x750d5
callq 0xd860
movq %rax, %rdi
movq 0x5e9df(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x5e97b(%rip), %rdi     # 0xacf40
leaq 0x26b17(%rip), %rsi     # 0x750e3
callq 0xd860
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0xdb80
movq %rax, %rdi
movq 0x5e9af(%rip), %rsi     # 0xacf98
callq 0xde80
movq 0x5e94b(%rip), %rdi     # 0xacf40
leaq 0x26aef(%rip), %rsi     # 0x750eb
callq 0xd860
movq %rax, %rdi
movq 0x5e98d(%rip), %rsi     # 0xacf98
callq 0xde80
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e6d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e700
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4e730
testb $0x1, %al
jne 0x4e649
jmp 0x4e688
leaq -0x18(%rbp), %rdi
callq 0x4e770
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4e790
movq %rax, %rsi
movq 0x5e8d7(%rip), %rdi     # 0xacf40
callq 0x4daf0
movq %rax, %rdi
movq 0x5e920(%rip), %rsi     # 0xacf98
callq 0xde80
leaq -0x18(%rbp), %rdi
callq 0x4e7c0
jmp 0x4e636
addq $0x30, %rsp
popq %rbp
retq
nop
// File: kztomita[P]http-dump/./http_protocol.h
// Function: create_socket(http_scheme, bool)
inline std::unique_ptr<sync_stream_wrapper> create_socket(http_scheme scheme, bool use_http2 = false) {
  if (scheme == http_scheme::https) {
    return std::make_unique<ssl_stream>(g_verify_cert, use_http2);
  } else {
    return std::make_unique<tcp_socket>();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x4ed13
leaq -0x18(%rbp), %rdi
leaq 0x5ec56(%rip), %rsi     # 0xad948
leaq -0xd(%rbp), %rdx
callq 0x4fb10
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4fba0
leaq -0x18(%rbp), %rdi
callq 0x4fbf0
jmp 0x4ed32
leaq -0x20(%rbp), %rdi
callq 0x4fc50
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4fcc0
leaq -0x20(%rbp), %rdi
callq 0x4fd10
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: kztomita[P]http-dump/./socket.h
// Function: bool read_line<sync_stream_wrapper>(sync_stream_wrapper&, boost::asio::basic_streambuf<std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool read_line(SyncReadStream& socket, boost::asio::streambuf& receive_buffer, std::string& line) {
  namespace asio = boost::asio;

  boost::system::error_code error;

  // receive_bufferにdelimiterより先のデータもまとめて読み込まれ場合がある。
  // この場合、sizeとreceive_buffer.size()が異ることがあるのでsizeの方を
  // 参照する必要がある。
  std::size_t size = asio::read_until(socket, receive_buffer, "\r\n", error);
  if (error && error != asio::error::eof) {
    throw std::runtime_error(error.message());
  }
  if (error == asio::error::eof) {
    return false;
  }

  const char* data = asio::buffer_cast<const char*>(receive_buffer.data());
  line.assign(data, size - 2);

  receive_buffer.consume(size);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10c60
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x48(%rbp), %rdi
leaq 0x22746(%rip), %rsi     # 0x75487
callq 0x10e50
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x548d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10ea0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb1(%rbp)
jne 0x52d83
jmp 0x52da8
leaq -0x58(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x54970
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x54940
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x52db7
jmp 0x52e5b
movb $0x1, -0x85(%rbp)
movl $0x10, %edi
callq 0xd580
movq %rax, -0xd0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10900
jmp 0x52dde
movq -0xd0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xd3e0
jmp 0x52df0
movq -0xd0(%rbp), %rdi
movb $0x0, -0x85(%rbp)
movq 0x5a18b(%rip), %rsi     # 0xacf90
movq 0x5a154(%rip), %rdx     # 0xacf60
callq 0xd970
jmp 0x52ef6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x52e3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xdac0
testb $0x1, -0x85(%rbp)
jne 0x52e4a
jmp 0x52e56
movq -0xd0(%rbp), %rdi
callq 0xdc70
jmp 0x52eed
leaq -0x98(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x54970
leaq -0x30(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x51c60
testb $0x1, %al
jne 0x52e86
jmp 0x52e8c
movb $0x0, -0x1(%rbp)
jmp 0x52edf
movq -0x18(%rbp), %rdi
callq 0x534d0
movq %rax, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x534b0
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq $0x2, %rdx
callq 0xd750
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x535f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
// File: kztomita[P]http-dump/./string_util_tolower.h
// Function: string_util::tolower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline std::string tolower(const std::string& str) {
  std::string s;

  std::transform(str.begin(), str.end(), std::back_inserter(s),
                 [](unsigned char c){ return std::tolower(c); });

  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xd510
movq -0x10(%rbp), %rdi
callq 0xd330
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdf30
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x4db70
movq %rax, -0x50(%rbp)
jmp 0x5320d
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x55ef0
movq %rax, -0x68(%rbp)
jmp 0x5322c
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x53260
jmp 0x53257
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xdac0
jmp 0x5326a
movq -0x58(%rbp), %rdi
callq 0xdac0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kztomita[P]http-dump/httpv2.cc
// Function: (anonymous namespace)::convert_header_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string convert_header_name(const std::string& name) {
  std::string converted;

  std::size_t i = 0;
  if (name[i] == ':') {
    i = 1;
  }

  bool upper = true;
  while (i < name.size()) {
    auto ch = name[i];
    if (upper && ch >= 'a' && ch <= 'z') {
      converted += std::toupper(ch);
      upper = false;
    } else {
      converted += std::tolower(ch);
    }
    if (ch == '-') {
      upper = true;
    }
    i++;
  }

  return converted;
}

// 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)
movb $0x0, -0x11(%rbp)
callq 0xd510
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xdfe0
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x59279
movq $0x1, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd440
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x59333
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xdfe0
movb (%rax), %al
movb %al, -0x22(%rbp)
testb $0x1, -0x21(%rbp)
je 0x592fc
movsbl -0x22(%rbp), %eax
cmpl $0x61, %eax
jl 0x592fc
movsbl -0x22(%rbp), %eax
cmpl $0x7a, %eax
jg 0x592fc
movsbl -0x22(%rbp), %edi
callq 0xd2b0
movq -0x48(%rbp), %rdi
movsbl %al, %esi
callq 0xda20
jmp 0x592df
movb $0x0, -0x21(%rbp)
jmp 0x59315
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xdac0
jmp 0x59350
movsbl -0x22(%rbp), %edi
callq 0xdc20
movq -0x48(%rbp), %rdi
movsbl %al, %esi
callq 0xda20
jmp 0x59313
jmp 0x59315
movsbl -0x22(%rbp), %eax
cmpl $0x2d, %eax
jne 0x59322
movb $0x1, -0x21(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5927d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x59346
movq -0x48(%rbp), %rdi
callq 0xdac0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xd990
nopl (%rax)
// File: kztomita[P]http-dump/./http2_socket.h
// Function: void send_http2_settings_ack<boost::asio::ssl::stream<boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::execution::any_executor<boost::asio::execution::context_as_t<boost::asio::execution_context&>, boost::asio::execution::detail::blocking::never_t<0>, boost::asio::execution::prefer_only<boost::asio::execution::detail::blocking::possibly_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::tracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::untracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::fork_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::continuation_t<0>>>>>>(boost::asio::ssl::stream<boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::execution::any_executor<boost::asio::execution::context_as_t<boost::asio::execution_context&>, boost::asio::execution::detail::blocking::never_t<0>, boost::asio::execution::prefer_only<boost::asio::execution::detail::blocking::possibly_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::tracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::untracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::fork_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::continuation_t<0>>>>>&)
void send_http2_settings_ack(SyncWriteStream& stream) {
  http2_frame settings;

  auto& header = settings.header();
  header.set_length(0);
  header.type = http2_frame_header::TYPE_SETTINGS;
  header.flags = 0x00;
  header.set_stream_id(0);
  header.flags = 0x01;  // ACK

  write_http2_frame(stream, settings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5c510
movq -0x50(%rbp), %rdi
callq 0x5c530
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x5c6c0
jmp 0x59bd3
movq -0x38(%rbp), %rax
movb $0x4, 0x3(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x5c540
jmp 0x59bf0
movq -0x38(%rbp), %rax
movb $0x1, 0x4(%rax)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5c770
jmp 0x59c07
leaq -0x30(%rbp), %rdi
callq 0x59c40
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x59c40
movq -0x40(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
nop
// File: kztomita[P]http-dump/./http2_frame.h
// Function: http2_frame_header::set_stream_id(unsigned int)
void set_stream_id(uint32_t sid) {
    if (sid & 0x80000000) {
      throw std::invalid_argument("sid too large");
    }
    uint32_t value = htonl(sid);
    std::memcpy(psid, &value, 4);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x5c5b4
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x19014(%rip), %rsi     # 0x75593
callq 0xd2e0
jmp 0x5c586
movq -0x30(%rbp), %rdi
movq 0x50997(%rip), %rsi     # 0xacf28
movq 0x50988(%rip), %rdx     # 0xacf20
callq 0xd970
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xdc70
jmp 0x5c5d1
movl -0xc(%rbp), %edi
callq 0xda40
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movl %ecx, 0x5(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xd990
nopw (%rax,%rax)
// File: kztomita[P]http-dump/./http2_frame.h
// Function: http2_frame_header::set_length(unsigned int)
void set_length(uint32_t length) {
    if (length & 0xff000000) {
      throw std::invalid_argument("length too large");
    }
    uint32_t value = htonl(length);
    std::memcpy(plength, (reinterpret_cast<uint8_t*>(&value)) + 1, 3);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
cmpl $0x0, %eax
je 0x5c734
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x18ea2(%rip), %rsi     # 0x755a1
callq 0xd2e0
jmp 0x5c706
movq -0x30(%rbp), %rdi
movq 0x50817(%rip), %rsi     # 0xacf28
movq 0x50808(%rip), %rdx     # 0xacf20
callq 0xd970
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xdc70
jmp 0x5c758
movl -0xc(%rbp), %edi
callq 0xda40
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x20(%rbp)
movw -0x1f(%rbp), %cx
movw %cx, (%rax)
movb -0x1d(%rbp), %cl
movb %cl, 0x2(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: kztomita[P]http-dump/./hpack_encoder.h
// Function: void hpack::encode_integer<std::vector<unsigned char, std::allocator<unsigned char>>>(unsigned char, unsigned int, unsigned long, std::vector<unsigned char, std::allocator<unsigned char>>&)
void encode_integer(uint8_t src, unsigned int i, std::size_t n, Container& buffer) {
  // 2 ^ n - 1
  unsigned int mask = (1 << n) - 1;

  if (i < mask) {
    buffer.push_back((src & ~mask) + (i & mask));
  } else {
    buffer.push_back(src | mask);
    i -= mask;
    while (i >= 128) {
      buffer.push_back(i % 128 + 128);
      i /= 128;
    }
    buffer.push_back(i);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x5df3a
movq -0x18(%rbp), %rdi
movzbl -0x1(%rbp), %eax
movl -0x1c(%rbp), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl -0x8(%rbp), %ecx
andl -0x1c(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x1d(%rbp)
leaq -0x1d(%rbp), %rsi
callq 0x5deb0
jmp 0x5df9e
movq -0x18(%rbp), %rdi
movzbl -0x1(%rbp), %eax
orl -0x1c(%rbp), %eax
movb %al, -0x1e(%rbp)
leaq -0x1e(%rbp), %rsi
callq 0x5deb0
movl -0x1c(%rbp), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
cmpl $0x80, -0x8(%rbp)
jb 0x5df8b
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %eax
andl $0x7f, %eax
addl $0x80, %eax
movb %al, -0x1f(%rbp)
leaq -0x1f(%rbp), %rsi
callq 0x5deb0
movl -0x8(%rbp), %eax
shrl $0x7, %eax
movl %eax, -0x8(%rbp)
jmp 0x5df5c
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %eax
movb %al, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x5deb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4e690
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4e6b0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq -0x20(%rbp), %rdi
callq 0x612c0
movq $0x0, -0x28(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x6058b
movq 0x4c9f9(%rip), %rdi     # 0xacf40
leaq 0x15214(%rip), %rsi     # 0x75762
callq 0xd860
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x612f0
movq -0x40(%rbp), %rdi
movzbl %al, %esi
callq 0xdb90
movq %rax, %rdi
movq 0x4ca1e(%rip), %rsi     # 0xacf98
callq 0xde80
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x60664
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x61380
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
leaq -0x20(%rbp), %rdi
callq 0x61380
movb %al, -0x2d(%rbp)
movq 0x4c97a(%rip), %rdi     # 0xacf40
leaq 0x152d3(%rip), %rsi     # 0x758a0
callq 0xd860
movq %rax, %rdi
movl -0x2c(%rbp), %ecx
andl $0x80000000, %ecx       # imm = 0x80000000
xorl %esi, %esi
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
callq 0xd4c0
movq %rax, %rdi
movq 0x4c99e(%rip), %rsi     # 0xacf98
callq 0xde80
movq %rax, %rdi
leaq 0x15166(%rip), %rsi     # 0x7576f
callq 0xd860
movq %rax, %rdi
movl -0x2c(%rbp), %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
callq 0xdb80
movq %rax, %rdi
movq 0x4c96f(%rip), %rsi     # 0xacf98
callq 0xde80
movq %rax, %rdi
leaq 0x1514b(%rip), %rsi     # 0x75783
callq 0xd860
movq %rax, %rdi
movzbl -0x2d(%rbp), %esi
callq 0xdb90
movq %rax, %rdi
movq 0x4c945(%rip), %rsi     # 0xacf98
callq 0xde80
movq -0x28(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x28(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kztomita[P]http-dump/http2_frame.cc
// Function: (anonymous namespace)::dump_settings_payload(std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned char)
void dump_settings_payload(const http2_frame::payload_type& payload, uint8_t flags) {
  auto buffer = buffer_view(&payload[0], payload.size());

  std::size_t offset = 0;

  while (buffer.test_range(offset, 6)) {
    uint16_t id = buffer.at_uint16(offset);
    uint32_t value = buffer.at_uint32(offset + 2);

    switch (id) {
    case SETTINGS_HEADER_TABLE_SIZE:
      std::cout << "SETTINGS_HEADER_TABLE_SIZE: ";
      break;
    case SETTINGS_ENABLE_PUSH:
      std::cout << "SETTINGS_ENABLE_PUSH: ";
      break;
    case SETTINGS_MAX_CONCURRENT_STREAMS:
      std::cout << "SETTINGS_MAX_CONCURRENT_STREAMS: ";
      break;
    case SETTINGS_INITIAL_WINDOW_SIZE:
      std::cout << "SETTINGS_INITIAL_WINDOW_SIZE: ";
      break;
    case SETTINGS_MAX_FRAME_SIZE:
      std::cout << "SETTINGS_MAX_FRAME_SIZE: ";
      break;
    case SETTINGS_MAX_HEADER_LIST_SIZE:
      std::cout << "SETTINGS_MAX_HEADER_LIST_SIZE: ";
      break;
    default:
      std::cout << "Unknown: ";
    }
    std::cout << value << std::endl;

    offset += 6;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4e690
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4e6b0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq -0x20(%rbp), %rdi
callq 0x612c0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x6, %edx
callq 0x61440
testb $0x1, %al
jne 0x607ff
jmp 0x60911
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x61490
movq -0x48(%rbp), %rdi
movw %ax, -0x2a(%rbp)
movq -0x28(%rbp), %rsi
addq $0x2, %rsi
callq 0x61380
movl %eax, -0x30(%rbp)
movzwl -0x2a(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x5, %eax
ja 0x608cf
movq -0x40(%rbp), %rax
leaq 0x14e08(%rip), %rcx     # 0x75650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x4c6e8(%rip), %rdi     # 0xacf40
leaq 0x15028(%rip), %rsi     # 0x75887
callq 0xd860
jmp 0x608e2
movq 0x4c6d3(%rip), %rdi     # 0xacf40
leaq 0x15030(%rip), %rsi     # 0x758a4
callq 0xd860
jmp 0x608e2
movq 0x4c6be(%rip), %rdi     # 0xacf40
leaq 0x15032(%rip), %rsi     # 0x758bb
callq 0xd860
jmp 0x608e2
movq 0x4c6a9(%rip), %rdi     # 0xacf40
leaq 0x1503f(%rip), %rsi     # 0x758dd
callq 0xd860
jmp 0x608e2
movq 0x4c694(%rip), %rdi     # 0xacf40
leaq 0x15049(%rip), %rsi     # 0x758fc
callq 0xd860
jmp 0x608e2
movq 0x4c67f(%rip), %rdi     # 0xacf40
leaq 0x1504e(%rip), %rsi     # 0x75916
callq 0xd860
jmp 0x608e2
movq 0x4c66a(%rip), %rdi     # 0xacf40
leaq 0x15059(%rip), %rsi     # 0x75936
callq 0xd860
movl -0x30(%rbp), %esi
movq 0x4c654(%rip), %rdi     # 0xacf40
callq 0xdb80
movq %rax, %rdi
movq 0x4c69d(%rip), %rsi     # 0xacf98
callq 0xde80
movq -0x28(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x28(%rbp)
jmp 0x607e4
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kztomita[P]http-dump/http2_frame.cc
// Function: (anonymous namespace)::dump_goaway_payload(std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned char)
void dump_goaway_payload(const http2_frame::payload_type& payload, uint8_t flags) {
  auto buffer = buffer_view(&payload[0], payload.size());

  uint32_t last_stream_id = buffer.at_uint32(0) & 0x7fffffff;
  uint32_t error_code = buffer.at_uint32(4);

  std::cout << "Last Stream Id: " << last_stream_id << std::endl
            << "Error Code: " << stringify_error_code(error_code) << "(" << error_code << ")" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x80(%rbp)
callq 0x4e690
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4e6b0
movq -0x88(%rbp), %rsi
movq %rax, %rdx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x612c0
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x61380
movq -0x78(%rbp), %rdi
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, -0x24(%rbp)
movl $0x4, %esi
callq 0x61380
movl %eax, -0x28(%rbp)
movq 0x4c5a6(%rip), %rdi     # 0xacf40
leaq 0x14f9f(%rip), %rsi     # 0x75940
callq 0xd860
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0xdb80
movq %rax, %rdi
movq 0x4c5dd(%rip), %rsi     # 0xacf98
callq 0xde80
movq %rax, %rdi
leaq 0x14dd1(%rip), %rsi     # 0x7579b
callq 0xd860
movq %rax, -0x70(%rbp)
movl -0x28(%rbp), %esi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x60b20
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xd480
movq %rax, -0x60(%rbp)
jmp 0x609f6
movq -0x60(%rbp), %rdi
leaq 0x152db(%rip), %rsi     # 0x75cdc
callq 0xd860
movq %rax, -0x90(%rbp)
jmp 0x60a0f
movq -0x90(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0xdb80
movq %rax, -0x98(%rbp)
jmp 0x60a27
movq -0x98(%rbp), %rdi
leaq 0x1270b(%rip), %rsi     # 0x73140
callq 0xd860
movq %rax, -0xa0(%rbp)
jmp 0x60a43
movq -0xa0(%rbp), %rdi
movq 0x4c547(%rip), %rsi     # 0xacf98
callq 0xde80
jmp 0x60a58
leaq -0x48(%rbp), %rdi
callq 0xdac0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xdac0
movq -0x50(%rbp), %rdi
callq 0xd990
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xdd60
movq -0x18(%rbp), %rdi
callq 0x61580
testb $0x1, %al
jne 0x611d9
movq -0x18(%rbp), %rdi
callq 0x61600
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rdi
movl $0x1, %esi
callq 0x615c0
movq %rax, -0x1f8(%rbp)
jmp 0x6112f
movq -0x1f8(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x18(%rbp), %rdi
callq 0x616b0
movq %rax, -0x1b8(%rbp)
movq -0x198(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq 0x145f5(%rip), %rdx     # 0x75757
leaq -0x1d0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x616e0
jmp 0x61177
movq -0x1b8(%rbp), %rsi
movq -0x1c0(%rbp), %rdx
leaq -0x1e0(%rbp), %rdi
leaq -0x1d0(%rbp), %rcx
callq 0x61630
jmp 0x6119a
leaq -0x198(%rbp), %rdi
callq 0x36180
movq %rax, %rsi
leaq -0x190(%rbp), %rdi
callq 0xd480
jmp 0x611b7
jmp 0x611d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xdcb0
jmp 0x6120a
movq -0x1f0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xe0c0
jmp 0x611ee
leaq -0x190(%rbp), %rdi
callq 0xdcb0
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0xd990
nopw %cs:(%rax,%rax)
// File: 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 %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 $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x613bc
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jb 0x6140c
movl $0x10, %edi
callq 0xd580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x143b5(%rip), %rsi     # 0x7578c
callq 0xdb30
jmp 0x613de
movq -0x38(%rbp), %rdi
movq 0x4bbe7(%rip), %rsi     # 0xacfd0
movq 0x4bb28(%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 0x61432
movq -0x30(%rbp), %rax
movl $0x0, -0x28(%rbp)
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0xe120
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xd990
nopl (%rax,%rax)
// File: kztomita[P]http-dump/./buffer_view.h
// Function: buffer_view<unsigned char>::test_range(unsigned long, unsigned long)
bool test_range(std::size_t offset, std::size_t length) {
    std::size_t end = offset + 1;
    if (end < offset || end > length_) {
      return false;
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x6147c
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x8(%rcx), %rax
jbe 0x61482
movb $0x0, -0x1(%rbp)
jmp 0x61486
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)