LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jimmiebergmann[P]fbx-file/fbx.cpp
// Function: unsigned long Fbx::(anonymous namespace)::PropertyReader::readPrimitiveValue<bool>() const
size_t readPrimitiveValue() const
            {
                T val;
                m_file.read(reinterpret_cast<char*>(&val), sizeof(T));
                m_pRecord->properties().insert(new Property(val));
                return sizeof(T);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rdi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x33b0
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x25fd0
movq %rax, -0x38(%rbp)
movl $0x40, %edi
callq 0x3310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movzbl -0x9(%rbp), %esi
andl $0x1, %esi
callq 0x208a0
jmp 0x26498
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x216d0
movq %rax, -0x28(%rbp)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x32e0
movq -0x18(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: jimmiebergmann[P]fbx-file/fbx.cpp
// Function: unsigned long Fbx::(anonymous namespace)::PropertyReader::readUncompressedArray<int>(unsigned int) const
size_t readUncompressedArray(uint32_t arrayLength) const
            {
                size_t size = arrayLength * sizeof(T);
                std::unique_ptr<T[]> data(new T[size]);
                m_file.read(reinterpret_cast<char*>(data.get()), size);
                m_pRecord->properties().insert(new Property(data.get(), arrayLength));
                return size + 12;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
shlq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2ac30
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x2ac60
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x33b0
jmp 0x26827
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x25fd0
movq %rax, -0x60(%rbp)
movl $0x40, %edi
callq 0x3310
movq %rax, -0x58(%rbp)
jmp 0x26848
leaq -0x20(%rbp), %rdi
callq 0x2ac60
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl -0xc(%rbp), %edx
callq 0x20b30
jmp 0x26862
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x216d0
movq %rax, -0x68(%rbp)
jmp 0x26875
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2ac90
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x268bf
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x32e0
leaq -0x20(%rbp), %rdi
callq 0x2ac90
movq -0x28(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: jimmiebergmann[P]fbx-file/examples/example1.cpp
// Function: main
int main()
{
    Fbx::Record file;
    auto versionCheck = [](std::string magic, uint32_t version)
    {
        if (magic != "Kaydara FBX Binary  ")
        {
            throw std::runtime_error("Invalid magic string.");
        }
        if (version < 7100)
        {
            throw std::runtime_error("I'm not interested in version less than 7100.");
        }
    };

    file.read("../models/blender-default.fbx", versionCheck);
    //printRecord(&file);
    file.write("../bin/out-model.fbx");

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x219c0
leaq -0x89(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3570
movq -0xf0(%rbp), %rdx
leaq 0x35da(%rip), %rsi      # 0x372e6
leaq -0x88(%rbp), %rdi
callq 0x3420
jmp 0x33d1a
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
leaq -0x61(%rbp), %rsi
callq 0x33e90
movq -0xf8(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x21e00
jmp 0x33d4a
leaq -0xc0(%rbp), %rdi
callq 0x288b0
leaq -0x88(%rbp), %rdi
callq 0x31c0
leaq -0x89(%rbp), %rdi
callq 0x3340
leaq -0xe1(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x3570
movq -0x100(%rbp), %rdx
leaq 0x3575(%rip), %rsi      # 0x37304
leaq -0xe0(%rbp), %rdi
callq 0x3420
jmp 0x33d9d
leaq -0x60(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x23540
jmp 0x33daf
leaq -0xe0(%rbp), %rdi
callq 0x31c0
leaq -0xe1(%rbp), %rdi
callq 0x3340
movl $0x0, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x21bd0
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x33e21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x288b0
leaq -0x88(%rbp), %rdi
callq 0x31c0
leaq -0x89(%rbp), %rdi
callq 0x3340
jmp 0x33e6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x33e61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x31c0
leaq -0xe1(%rbp), %rdi
callq 0x3340
leaq -0x60(%rbp), %rdi
callq 0x21bd0
movq -0x98(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_gnuplot_multi.cpp
// Function: exprtk_gnuplot_fx::plot()
bool plot()
   {
      for (std::size_t i = 0; i < curve_list_.size(); ++i)
      {
         if (!generate_data(i,curve_list_[i]))
            return false;
      }

      return generate_gp_script();
   }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x119a70
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x118ea5
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x11a850
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x11a1b0
testb $0x1, %al
jne 0x118e93
movb $0x0, 0x37(%rsp)
jmp 0x118eb5
jmp 0x118e95
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x118e3c
movq 0x18(%rsp), %rdi
callq 0x11a880
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: rocket323[P]fishdb/tests/test_main.cpp
// Function: FillPage(std::shared_ptr<fishdb::MemPage>)
void FillPage(std::shared_ptr<MemPage> mp)
{
    for (int i = 0; i < ks; ++i)
        mp->children.push_back(100);
    for (int i = 0; i < ks; ++i)
        mp->kvs.push_back(KV("hello", "world"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x1abc2(%rip), %eax     # 0x1e248
jge 0x36b7
movq -0xc8(%rbp), %rdi
callq 0x49a0
movq %rax, %rdi
addq $0x48, %rdi
movq $0x64, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x49c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x367d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x1ab81(%rip), %eax     # 0x1e248
jge 0x3831
movq -0xc8(%rbp), %rdi
callq 0x49a0
addq $0x60, %rax
movq %rax, -0xd8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3440
movq -0xd0(%rbp), %rdx
leaq 0x1192b(%rip), %rsi     # 0x15030
leaq -0x80(%rbp), %rdi
callq 0x3350
jmp 0x3710
leaq -0xb9(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3440
movq -0xe0(%rbp), %rdx
leaq 0x11905(%rip), %rsi     # 0x15036
leaq -0xb8(%rbp), %rdi
callq 0x3350
jmp 0x373f
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x4a20
jmp 0x3755
movq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x49f0
jmp 0x3767
leaq -0x60(%rbp), %rdi
callq 0x4a80
leaq -0xb8(%rbp), %rdi
callq 0x3160
leaq -0xb9(%rbp), %rdi
callq 0x32b0
leaq -0x80(%rbp), %rdi
callq 0x3160
leaq -0x81(%rbp), %rdi
callq 0x32b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x36be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x3823
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x380e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x3802
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4a80
leaq -0xb8(%rbp), %rdi
callq 0x3160
leaq -0xb9(%rbp), %rdi
callq 0x32b0
leaq -0x80(%rbp), %rdi
callq 0x3160
leaq -0x81(%rbp), %rdi
callq 0x32b0
jmp 0x383a
addq $0xe0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: dump
void dump (void) {
  Clause * p;
  printf ("p cnf %d %d\n", nvars, nclauses);
  for (p = first_clause; p; p = p->next)
    dump_clause (p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x1fe1a(%rip), %esi     # 0x21118
movl 0x1fe18(%rip), %edx     # 0x2111c
leaq 0x18cf9(%rip), %rdi     # 0x1a004
movb $0x0, %al
callq 0x10b0
movq 0x1fe07(%rip), %rax     # 0x21120
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x133b
movq -0x8(%rbp), %rdi
callq 0x1350
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x131d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: dump_clause
static void dump_clause (Clause * c) {
  int * p, lit;
  for (p = c->lits; (lit = *p); p++)
    printf ("%d ", lit);
  printf ("0\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x1395
movl -0x14(%rbp), %esi
leaq 0x18d7e(%rip), %rdi     # 0x1a0fe
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x1368
leaq 0x19c52(%rip), %rdi     # 0x1afee
movb $0x0, %al
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: encode
static void encode (void) {
  Clause * p;
  first_cid = nvars + 1;
  last_cid = nvars + nclauses;
  msg (2, "selector variables range %d to %d", first_cid, last_cid);
  for (p = first_clause; p; p = p->next)
    encode_clause (p);
  msg (1, "encoded %d clauses", nclauses);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x1f6fa(%rip), %eax     # 0x21118
addl $0x1, %eax
movl %eax, 0x1f731(%rip)     # 0x21158
movl 0x1f6eb(%rip), %eax     # 0x21118
addl 0x1f6e9(%rip), %eax     # 0x2111c
movl %eax, 0x1f723(%rip)     # 0x2115c
movl 0x1f719(%rip), %edx     # 0x21158
movl 0x1f717(%rip), %ecx     # 0x2115c
movl $0x2, %edi
leaq 0x187f7(%rip), %rsi     # 0x1a248
movb $0x0, %al
callq 0x1e10
movq 0x1f6c1(%rip), %rax     # 0x21120
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1a81
movq -0x8(%rbp), %rdi
callq 0x2080
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a63
movl 0x1f695(%rip), %edx     # 0x2111c
movl $0x1, %edi
leaq 0x187d7(%rip), %rsi     # 0x1a26a
movb $0x0, %al
callq 0x1e10
addq $0x10, %rsp
popq %rbp
retq
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: cumcs
static void cumcs (void) {
  int stats[2], count, cid;
  const int * humus, * p;
  stats[0] = stats[1] = 0;
  humus = picosat_humus (ps, cumcscb, stats);
  if (isatty (1) && verbose == 1) fputc ('\n', stdout);
  count = 0;
  for (p = humus; (cid = *p); p++) {
    if (marked[cid]) continue;
    marked[cid] = 1;
    count++;
  }
  assert (count == stats[1]);
  msg (1, 
    "computed union of minimal correcting sets of size %d with %d mcs", 
    stats[1], stats[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movq 0x1f693(%rip), %rdi     # 0x21150
leaq -0x8(%rbp), %rdx
leaq 0x728(%rip), %rsi       # 0x21f0
callq 0x8c60
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x1080
cmpl $0x0, %eax
je 0x1afd
cmpl $0x1, 0x1f641(%rip)     # 0x21128
jne 0x1afd
movq 0x1f4e0(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10f0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0x1b53
movq 0x1f63f(%rip), %rax     # 0x21160
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1b2d
jmp 0x1b45
movq 0x1f62c(%rip), %rax     # 0x21160
movslq -0x10(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b0c
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x1b5d
jmp 0x1b7c
leaq 0x18778(%rip), %rdi     # 0x1a2dc
leaq 0x18606(%rip), %rsi     # 0x1a171
movl $0xfd, %edx
leaq 0x18777(%rip), %rcx     # 0x1a2ee
callq 0x10c0
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl $0x1, %edi
leaq 0x18771(%rip), %rsi     # 0x1a2ff
movb $0x0, %al
callq 0x1e10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: camcs
static void camcs (void) {
  int cid, i;
  const int * mcs, * p;
  msg (1, "starting to compute all minimal correcting sets");
  while ((mcs = picosat_next_minimal_correcting_subset_of_assumptions (ps))) {
    for (p = mcs; (cid = *p); p++)
      push_stack (cid);
    if (verbose >= 2) {
      printf ("c [picomcs] mcs %d :", nmcs);
      for (i = 0; i < nstk; i++) printf (" %d", stk[i] - nvars);
      fputc ('\n', stdout);
      fflush (stdout);
    } else if (verbose && isatty (1)) {
      printf ("\rc [picomcs] mcs %d", nmcs);
      fflush (stdout);
    }
    push_mcs ();
  }
  if (verbose && isatty (1)) fputc ('\r', stdout);
  msg (1, "found %d minimal correcting sets", nmcs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %edi
leaq 0x187a8(%rip), %rsi     # 0x1a35c
movb $0x0, %al
callq 0x1e10
movq 0x1f58e(%rip), %rdi     # 0x21150
callq 0x8bf0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1cc9
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
je 0x1c01
movl -0x4(%rbp), %edi
callq 0x1f30
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x1bdd
cmpl $0x2, 0x1f520(%rip)     # 0x21128
jl 0x1c82
movl 0x1f570(%rip), %esi     # 0x21180
leaq 0x18775(%rip), %rdi     # 0x1a38c
movb $0x0, %al
callq 0x10b0
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x1f53a(%rip), %eax     # 0x21168
jge 0x1c5d
movq 0x1f539(%rip), %rax     # 0x21170
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %esi
subl 0x1f4d4(%rip), %esi     # 0x21118
leaq 0x184f0(%rip), %rdi     # 0x1a13b
movb $0x0, %al
callq 0x10b0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1c25
movq 0x1f36c(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10f0
movq 0x1f358(%rip), %rax     # 0x20fd0
movq (%rax), %rdi
callq 0x1140
jmp 0x1cbf
cmpl $0x0, 0x1f49f(%rip)     # 0x21128
je 0x1cbd
movl $0x1, %edi
callq 0x1080
cmpl $0x0, %eax
je 0x1cbd
movl 0x1f4e0(%rip), %esi     # 0x21180
leaq 0x186fa(%rip), %rdi     # 0x1a3a1
movb $0x0, %al
callq 0x10b0
movq 0x1f31b(%rip), %rax     # 0x20fd0
movq (%rax), %rdi
callq 0x1140
jmp 0x1cbf
callq 0x22b0
jmp 0x1bbb
cmpl $0x0, 0x1f458(%rip)     # 0x21128
je 0x1cf5
movl $0x1, %edi
callq 0x1080
cmpl $0x0, %eax
je 0x1cf5
movq 0x1f2e8(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
movl $0xd, %edi
callq 0x10f0
movl 0x1f485(%rip), %edx     # 0x21180
movl $0x1, %edi
leaq 0x186ae(%rip), %rsi     # 0x1a3b5
movb $0x0, %al
callq 0x1e10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: print_umcs
static void
print_umcs (void) {
  int cid;
  printf ("v");
  for (cid = first_cid; cid <= last_cid; cid++)
    if (marked[cid])
      printf (" %d", cid - nvars);
  printf (" 0\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1b138(%rip), %rdi     # 0x1ce67
movb $0x0, %al
callq 0x10b0
movl 0x1f41c(%rip), %eax     # 0x21158
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x1f414(%rip), %eax     # 0x2115c
jg 0x1d7f
movq 0x1f40f(%rip), %rax     # 0x21160
movslq -0x4(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1d72
movl -0x4(%rbp), %esi
subl 0x1f3b4(%rip), %esi     # 0x21118
leaq 0x183d0(%rip), %rdi     # 0x1a13b
movb $0x0, %al
callq 0x10b0
jmp 0x1d74
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d3f
leaq 0x19267(%rip), %rdi     # 0x1afed
movb $0x0, %al
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: release
static void release (void) {
  release_clauses ();
  release_mss ();
  free (marked);
  free (stk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x23e0
callq 0x2430
movq 0x1f36b(%rip), %rdi     # 0x21160
callq 0x1040
movq 0x1f36f(%rip), %rdi     # 0x21170
callq 0x1040
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: msg
static void msg (int level, const char * fmt, ...) {
  va_list ap;
  if (level > verbose) return;
  printf ("c [picomcs] ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1e48
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x1f2b4(%rip), %eax     # 0x21128
jle 0x1e78
jmp 0x1ede
leaq 0x183bc(%rip), %rdi     # 0x1a23b
movb $0x0, %al
callq 0x10b0
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1160
leaq -0x30(%rbp), %rax
movq 0x1f10e(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10f0
movq 0x1f0fa(%rip), %rax     # 0x20fd0
movq (%rax), %rdi
callq 0x1140
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: push_clause
static void push_clause (void) {
  Clause * clause;
  size_t bytes;
  clause = malloc (sizeof *clause);
  clause->cid = ++nclauses;
  clause->next = 0;
  push_stack (0);
  bytes = nstk * sizeof *clause->lits;
  clause->lits = malloc (bytes);
  memcpy (clause->lits, stk, bytes);
  if (last_clause) last_clause->next = clause;
  else first_clause = clause;
  last_clause = clause;
  nstk = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x1130
movq %rax, -0x8(%rbp)
movl 0x1f140(%rip), %ecx     # 0x2111c
addl $0x1, %ecx
movl %ecx, 0x1f137(%rip)     # 0x2111c
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
xorl %edi, %edi
callq 0x1f30
movslq 0x1f163(%rip), %rax     # 0x21168
shlq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x1f140(%rip), %rsi     # 0x21170
movq -0x10(%rbp), %rdx
callq 0x1120
cmpq $0x0, 0x1f137(%rip)     # 0x21178
je 0x2054
movq -0x8(%rbp), %rcx
movq 0x1f12a(%rip), %rax     # 0x21178
movq %rcx, 0x10(%rax)
jmp 0x205f
movq -0x8(%rbp), %rax
movq %rax, 0x1f0c1(%rip)     # 0x21120
movq -0x8(%rbp), %rax
movq %rax, 0x1f10e(%rip)     # 0x21178
movl $0x0, 0x1f0f4(%rip)     # 0x21168
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: encode_clause
static void encode_clause (Clause * c) {
  int * p, lit;
  if (verbose >= 2) {
    printf ("c [picomcs] encode clause %d :", c->cid);
    printf (" %d", -clause2selvar (c));
    for (p = c->lits; (lit = *p); p++) printf (" %d", lit);
    fputc ('\n', stdout), fflush (stdout);
  }
  picosat_add (ps, -clause2selvar (c));
  for (p = c->lits; (lit = *p); p++) picosat_add (ps, lit);
  picosat_add (ps, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x2, 0x1f095(%rip)     # 0x21128
jl 0x2124
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x181d7(%rip), %rdi     # 0x1a27d
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x2190
xorl %esi, %esi
subl %eax, %esi
leaq 0x1807a(%rip), %rdi     # 0x1a13b
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x2101
movl -0x14(%rbp), %esi
leaq 0x1804f(%rip), %rdi     # 0x1a13b
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x20d4
movq 0x1eec8(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10f0
movq 0x1eeb4(%rip), %rax     # 0x20fd0
movq (%rax), %rdi
callq 0x1140
movq 0x1f025(%rip), %rax     # 0x21150
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
xorl %esi, %esi
subl %eax, %esi
callq 0x50f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x217c
movq 0x1efea(%rip), %rdi     # 0x21150
movl -0x14(%rbp), %esi
callq 0x50f0
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x2151
movq 0x1efcd(%rip), %rdi     # 0x21150
xorl %esi, %esi
callq 0x50f0
addq $0x20, %rsp
popq %rbp
retq
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: cumcscb
static void cumcscb (void * state, int nmcs, int nhumus) {
  int * ptr = state;
  *ptr = nmcs;
  ptr[0] = nmcs, ptr[1] = nhumus;
  if (!verbose || (!isatty (1) && verbose == 1)) return;
  if (verbose == 1) fputc ('\r', stdout);
  printf ("c [picomcs] mcs %d humus %d", nmcs, nhumus);
  if (verbose >= 2) fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
cmpl $0x0, 0x1eefb(%rip)     # 0x21128
je 0x2247
movl $0x1, %edi
callq 0x1080
cmpl $0x0, %eax
jne 0x2249
cmpl $0x1, 0x1eee3(%rip)     # 0x21128
jne 0x2249
jmp 0x22a6
cmpl $0x1, 0x1eed8(%rip)     # 0x21128
jne 0x2266
movq 0x1ed77(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
movl $0xd, %edi
callq 0x10f0
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x180cd(%rip), %rdi     # 0x1a340
movb $0x0, %al
callq 0x10b0
cmpl $0x2, 0x1eea7(%rip)     # 0x21128
jl 0x2297
movq 0x1ed46(%rip), %rax     # 0x20fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10f0
movq 0x1ed32(%rip), %rax     # 0x20fd0
movq (%rax), %rdi
callq 0x1140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: push_mcs
static void push_mcs (void) {
  MCS * mcs;
  size_t bytes;
  mcs = malloc (sizeof *mcs);
  mcs->mid = ++nmcs;
  mcs->next = 0;
  push_stack (0);
  bytes = nstk * sizeof *mcs->clauses;
  mcs->clauses = malloc (bytes);
  memcpy (mcs->clauses, stk, bytes);
  if (last_mcs) last_mcs->next = mcs;
  else first_mcs = mcs;
  last_mcs = mcs;
  nstk = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x1130
movq %rax, -0x8(%rbp)
movl 0x1eeb4(%rip), %ecx     # 0x21180
addl $0x1, %ecx
movl %ecx, 0x1eeab(%rip)     # 0x21180
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
xorl %edi, %edi
callq 0x1f30
movslq 0x1ee73(%rip), %rax     # 0x21168
shlq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x1ee50(%rip), %rsi     # 0x21170
movq -0x10(%rbp), %rdx
callq 0x1120
cmpq $0x0, 0x1ee57(%rip)     # 0x21188
je 0x2344
movq -0x8(%rbp), %rcx
movq 0x1ee4a(%rip), %rax     # 0x21188
movq %rcx, 0x10(%rax)
jmp 0x234f
movq -0x8(%rbp), %rax
movq %rax, 0x1ee41(%rip)     # 0x21190
movq -0x8(%rbp), %rax
movq %rax, 0x1ee2e(%rip)     # 0x21188
movl $0x0, 0x1ee04(%rip)     # 0x21168
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: print_mcs
static void
print_mcs (MCS * mcs) 
{
  const int * p;
  int cid;
  printf ("v");
  for (p = mcs->clauses; (cid = *p); p++)
    printf (" %d", cid - nvars);
  printf (" 0\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1aae4(%rip), %rdi     # 0x1ce67
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x23c9
movl -0x14(%rbp), %esi
subl 0x1ed6b(%rip), %esi     # 0x21118
leaq 0x17d87(%rip), %rdi     # 0x1a13b
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x2396
leaq 0x18c1d(%rip), %rdi     # 0x1afed
movb $0x0, %al
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: release_clauses
static void release_clauses (void) {
  Clause * p, * next;
  for (p = first_clause; p; p = next) {
    next = p->next;
    free (p->lits);
    free (p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1ed31(%rip), %rax     # 0x21120
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2426
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23f3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomcs.c
// Function: release_mss
static void release_mss (void) {
  MCS * p, * next;
  for (p = first_mcs; p; p = next) {
    next = p->next;
    free (p->clauses);
    free (p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1ed51(%rip), %rax     # 0x21190
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2476
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2443
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: get_line(int, char*, int)
int get_line(int sock, char *buf, int size)
{
	int i = 0;
	char c = '\0';
	int n;

	while ((i < size - 1) && (c != '\n'))
	{
		n = recv(sock, &c, 1, 0);
  /* DEBUG printf("%02X\n", c); */
		if (n > 0)
		{
			if (c == '\r')
			{
				n = recv(sock, &c, 1, MSG_PEEK);
    /* DEBUG printf("%02X\n", c); */
				if ((n > 0) && (c == '\n'))
					recv(sock, &c, 1, 0);
				else
					c = '\n';
			}
			buf[i] = c;
			i++;
		}
		else
			c = '\n';
	}
	buf[i] = '\0';

	return(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jge 0x3bec
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3bf8
jmp 0x3c82
movl -0x4(%rbp), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3110
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x3c79
movsbl -0x19(%rbp), %eax
cmpl $0xd, %eax
jne 0x3c60
movl -0x4(%rbp), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x3110
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x3c5a
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
jne 0x3c5a
movl -0x4(%rbp), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3110
jmp 0x3c5e
movb $0xa, -0x19(%rbp)
jmp 0x3c60
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3c7d
movb $0xa, -0x19(%rbp)
jmp 0x3bcd
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: serve_file(int, char const*)
void serve_file(int client, const char *filename)
{
	FILE *resource = NULL;
	int numchars = 1;
	char buf[1024];
	buf[0] = 'A'; buf[1] = '\0';//这个赋值不清楚是干什么的
	while ((numchars > 0) && strcmp("\n", buf)) //将HTTP请求头读取并丢弃
		numchars = get_line(client, buf, sizeof(buf));
//打开文件
	resource = fopen(filename, "r");
	if (resource == NULL)
 //如果文件不存在，则返回not_found
		not_found(client);
	else
	{
 //添加HTTP头
		headers(client, filename);
 //并发送文件内容
		cat(client, resource);
	}
	fclose(resource);//关闭文件句柄
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movb $0x41, -0x420(%rbp)
movb $0x0, -0x41f(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x421(%rbp)
jle 0x426c
leaq -0x420(%rbp), %rsi
leaq 0xb0fe(%rip), %rdi      # 0xf359
callq 0x3460
cmpl $0x0, %eax
setne %al
movb %al, -0x421(%rbp)
movb -0x421(%rbp), %al
testb $0x1, %al
jne 0x4278
jmp 0x4291
movl -0x4(%rbp), %edi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3bb0
movl %eax, -0x1c(%rbp)
jmp 0x423f
movq -0x10(%rbp), %rdi
leaq 0xb00c(%rip), %rsi      # 0xf2a8
callq 0x3400
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x42b6
movl -0x4(%rbp), %edi
callq 0x3f30
jmp 0x42ce
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x49e0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x47c0
movq -0x18(%rbp), %rdi
callq 0x3380
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: bad_request(int)
void bad_request(int client)
{
	char buf[1024];
//发送400
	sprintf(buf, "HTTP/1.0 400 BAD REQUEST\r\n");
	send(client, buf, sizeof(buf), 0);
	sprintf(buf, "Content-type: text/html\r\n");
	send(client, buf, sizeof(buf), 0);
	sprintf(buf, "\r\n");
	send(client, buf, sizeof(buf), 0);
	sprintf(buf, "<P>Your browser sent a bad request, ");
	send(client, buf, sizeof(buf), 0);
	sprintf(buf, "such as a POST without a Content-Length.\r\n");
	send(client, buf, sizeof(buf), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movl %edi, -0x4(%rbp)
leaq -0x410(%rbp), %rdi
leaq 0xa9a2(%rip), %rsi      # 0xf08e
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xa992(%rip), %rsi      # 0xf0a9
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xac16(%rip), %rsi      # 0xf358
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xa956(%rip), %rsi      # 0xf0c3
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xa950(%rip), %rsi      # 0xf0e8
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x31d0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nop
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: cat(int, _IO_FILE*)
void cat(int client, FILE *resource)
{
//发送文件的内容
	char buf[1024];
//读取文件到buf中
	fgets(buf, sizeof(buf), resource);
	while (!feof(resource))//判断文件是否读取到末尾
	{
 //读取并发送文件内容
		send(client, buf, strlen(buf), 0);
		fgets(buf, sizeof(buf), resource);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x34e0
movq -0x10(%rbp), %rdi
callq 0x34c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x47fe
jmp 0x484f
movl -0x4(%rbp), %eax
movl %eax, -0x41c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x41c(%rbp), %edi
movq -0x418(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x34e0
jmp 0x47e7
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax,%rax)
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: cannot_execute(int)
void cannot_execute(int client)
{
	char buf[1024];
//发送500
	sprintf(buf, "HTTP/1.0 500 Internal Server Error\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "Content-type: text/html\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "\r\n");
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "<P>Error prohibited CGI execution.\r\n");
	send(client, buf, strlen(buf), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movl %edi, -0x4(%rbp)
leaq -0x410(%rbp), %rdi
leaq 0xa897(%rip), %rsi      # 0xf113
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %eax
movl %eax, -0x44c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x448(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x44c(%rbp), %edi
movq -0x448(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xa7de(%rip), %rsi      # 0xf0a9
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %eax
movl %eax, -0x43c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x438(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x43c(%rbp), %edi
movq -0x438(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xaa3e(%rip), %rsi      # 0xf358
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %eax
movl %eax, -0x42c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x42c(%rbp), %edi
movq -0x428(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xa7cf(%rip), %rsi      # 0xf138
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %eax
movl %eax, -0x41c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x41c(%rbp), %edi
movq -0x418(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: headers(int, char const*)
void headers(int client, const char *filename)
{
	char buf[1024];
	(void)filename;  /* could use filename to determine file type */
//发送HTTP头
	strcpy(buf, "HTTP/1.0 200 OK\r\n");
	send(client, buf, strlen(buf), 0);
	strcpy(buf, SERVER_STRING);
	send(client, buf, strlen(buf), 0);
	sprintf(buf, "Content-Type: text/html\r\n");
	send(client, buf, strlen(buf), 0);
	strcpy(buf, "\r\n");
	send(client, buf, strlen(buf), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
leaq 0xa76d(%rip), %rsi      # 0xf16d
callq 0x3350
movl -0x4(%rbp), %eax
movl %eax, -0x44c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x448(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x44c(%rbp), %edi
movq -0x448(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xa766(%rip), %rsi      # 0xf1b3
callq 0x3350
movl -0x4(%rbp), %eax
movl %eax, -0x43c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x438(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x43c(%rbp), %edi
movq -0x438(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xa732(%rip), %rsi      # 0xf1cc
movb $0x0, %al
callq 0x3070
movl -0x4(%rbp), %eax
movl %eax, -0x42c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x42c(%rbp), %edi
movq -0x428(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
leaq -0x410(%rbp), %rdi
leaq 0xa86f(%rip), %rsi      # 0xf358
callq 0x3350
movl -0x4(%rbp), %eax
movl %eax, -0x41c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3170
movl -0x41c(%rbp), %edi
movq -0x418(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x31d0
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/httpd.cpp
// Function: startup(unsigned short*)
int startup(u_short *port)
{

//服务器处理步骤
/*
第一步：创建端口号，使用函数int socketid = socket(family, type, protocol);;
第二步：将地址结构体绑定在端口号上，使用函数int bind(int fd, const struct sockaddr *, socklen_t);
第三步：循环监听客户端请求，使用函数listen(sockfd, 5);（第一个参数是 socket 描述符，第二个参数是最大连接数）

第四步：接受客户端的请求，new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c);
第五步：使用read()/write()进行数据交换
第六步：关闭连接，使用close(socketid);
*/


//客户端处理步骤
/*
第一步：创建端口号，使用函数int socketid = socket(family, type, protocol);
第二步：将地址结构体绑定在端口号上，使用函数int bind(int fd, const struct sockaddr *, socklen_t);
第三步：请求连接，使用函数int connect(int socket, const struct sockaddr* address, size_t address_len)；

第四步：使用read()/write()进行数据交换；
第五步：关闭连接，使用close(socketid);
*/
	int httpd = 0;
	struct sockaddr_in name;
//设置http socket
	httpd = socket(PF_INET, SOCK_STREAM, 0);
	if (httpd == -1)
		error_die("socket");
	memset(&name, 0, sizeof(name));

 //创建地址结构体struct sockaddr_in，主要包含地址和端口号
	name.sin_family = AF_INET;
	name.sin_port = htons(*port);
	name.sin_addr.s_addr = htonl(INADDR_ANY);


 //绑定端口
	if (bind(httpd, (struct sockaddr *)&name, sizeof(name)) < 0)
		error_die("bind");
	if (*port == 0)  /*动态分配一个端口 */
	{
		socklen_t  namelen = sizeof(name);
		if (getsockname(httpd, (struct sockaddr *)&name, &namelen) == -1)
			error_die("getsockname");
		*port = ntohs(name.sin_port);
	}
 //监听连接
	if (listen(httpd, 5) < 0)
		error_die("listen");
	return(httpd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30a0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x4b79
leaq 0xa736(%rip), %rdi      # 0xf2aa
callq 0x49c0
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31f0
movw $0x2, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x3040
movw %ax, -0x1a(%rbp)
xorl %edi, %edi
callq 0x3280
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x10, %edx
callq 0x3060
cmpl $0x0, %eax
jge 0x4bcb
leaq 0xa6eb(%rip), %rdi      # 0xf2b1
callq 0x49c0
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
jne 0x4c12
movl $0x10, -0x20(%rbp)
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3330
cmpl $-0x1, %eax
jne 0x4bff
leaq 0xa6bc(%rip), %rdi      # 0xf2b6
callq 0x49c0
movzwl -0x1a(%rbp), %edi
callq 0x3580
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movl -0xc(%rbp), %edi
movl $0x5, %esi
callq 0x33f0
cmpl $0x0, %eax
jge 0x4c30
leaq 0xa697(%rip), %rdi      # 0xf2c2
callq 0x49c0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/./ThreadPool.h
// Function: ThreadPool::ThreadPool(unsigned long)
inline ThreadPool::ThreadPool(size_t threads)
    :   stop(false)
{
    for(size_t i = 0;i<threads;++i)
        workers.emplace_back(
            [this]
            {
                for(;;)
                {
                    std::function<void()> task;

                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock,
                            [this]{ return this->stop || !this->tasks.empty(); });
                        if(this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }

                    task();
                }
            }
        );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x5510
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x5530
jmp 0x50b7
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x5560
movq -0x48(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3470
movq -0x48(%rbp), %rax
movb $0x0, 0xc0(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5146
movq -0x48(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x5580
jmp 0x5108
jmp 0x510a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x50eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x514c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3570
movq -0x38(%rbp), %rdi
callq 0x5600
jmp 0x514c
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5620
movq -0x18(%rbp), %rdi
callq 0x3550
nop
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/./ThreadPool.h
// Function: std::future<std::result_of<void* (& (void*))(void*)>::type> ThreadPool::enqueue<void* (&)(void*), void*>(void* (&)(void*), void*&&)
auto ThreadPool::enqueue(F&& f, Args&&... args) 
    -> std::future<typename std::result_of<F(Args...)>::type>
{
    using return_type = typename std::result_of<F(Args...)>::type;

    auto task = std::make_shared< std::packaged_task<return_type()> >(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        
    std::future<return_type> res = task->get_future();
    {
        std::unique_lock<std::mutex> lock(queue_mutex);

        // don't allow enqueueing after stopping the pool
        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");

        tasks.emplace([task](){ (*task)(); });
    }
    condition.notify_one();
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x83a0
movq -0x90(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x8330
movq -0x88(%rbp), %rdi
movb $0x0, -0x41(%rbp)
callq 0x83e0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x8400
jmp 0x5281
movq -0x98(%rbp), %rsi
addq $0x68, %rsi
leaq -0x68(%rbp), %rdi
callq 0x6910
jmp 0x5297
movq -0x98(%rbp), %rax
testb $0x1, 0xc0(%rax)
je 0x533f
movl $0x10, %edi
callq 0x31b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
leaq 0xa145(%rip), %rsi      # 0xf40e
callq 0x3150
jmp 0x52d0
movq -0xa8(%rbp), %rdi
movq 0x12d12(%rip), %rsi     # 0x17ff0
movq 0x12cc3(%rip), %rdx     # 0x17fa8
callq 0x3540
jmp 0x5408
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x53f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x53ed
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x3250
jmp 0x53c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x53c0
movq -0x98(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xb8(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x84a0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x8470
jmp 0x537a
leaq -0x78(%rbp), %rdi
callq 0x84d0
leaq -0x68(%rbp), %rdi
callq 0x6a50
movq -0x98(%rbp), %rdi
addq $0x90, %rdi
callq 0x31c0
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x53d4
jmp 0x53cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x84d0
leaq -0x68(%rbp), %rdi
callq 0x6a50
jmp 0x53ed
movq -0x80(%rbp), %rdi
callq 0x5410
leaq -0x30(%rbp), %rdi
callq 0x84f0
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x5410
leaq -0x30(%rbp), %rdi
callq 0x84f0
movq -0x50(%rbp), %rdi
callq 0x3550
nopl (%rax,%rax)
// File: fltflt[P]Tinyhttpd_with_threadpool_epoll/./ThreadPool.h
// Function: ThreadPool::~ThreadPool()
inline ThreadPool::~ThreadPool()
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for(std::thread &worker: workers)
        worker.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x68, %rsi
leaq -0x18(%rbp), %rdi
callq 0x6910
jmp 0x5453
movq -0x40(%rbp), %rax
movb $0x1, 0xc0(%rax)
leaq -0x18(%rbp), %rdi
callq 0x6a50
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
callq 0x3520
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7510
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6330
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x82d0
testb $0x1, %al
jne 0x54ac
jmp 0x54d1
leaq -0x28(%rbp), %rdi
callq 0x7cc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3530
jmp 0x54c4
jmp 0x54c6
leaq -0x28(%rbp), %rdi
callq 0x8310
jmp 0x5499
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
callq 0x3570
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x5600
movq -0x40(%rbp), %rdi
callq 0x5620
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5c20
nopw %cs:(%rax,%rax)
nop
// File: 111116[P]console/example.cpp
// Function: main
int main()
{
	console.log("Here prints a log");
	console.info("Here prints an info.");
	console.warn("Here prints a warning!");
	console.error("Here prints an error!!");
	console.log("multiple variables",1,2,3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4db1(%rip), %rdi      # 0x60e0
leaq 0x1cd2(%rip), %rsi      # 0x3008
callq 0x1610
leaq 0x4d9e(%rip), %rdi      # 0x60e0
leaq 0x1cd1(%rip), %rsi      # 0x301a
callq 0x1680
leaq 0x4d8b(%rip), %rdi      # 0x60e0
leaq 0x1cd3(%rip), %rsi      # 0x302f
callq 0x1720
leaq 0x4d78(%rip), %rdi      # 0x60e0
leaq 0x1cd7(%rip), %rsi      # 0x3046
callq 0x17c0
movl $0x1, -0x4(%rbp)
movl $0x2, -0x8(%rbp)
movl $0x3, -0xc(%rbp)
leaq 0x4d50(%rip), %rdi      # 0x60e0
leaq 0x1cc6(%rip), %rsi      # 0x305d
leaq -0x4(%rbp), %rdx
leaq -0x8(%rbp), %rcx
leaq -0xc(%rbp), %r8
callq 0x1860
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: adrianphoulady[P]weighted-tsetlin-machine-cpp/./utils.h
// Function: getopt(int, char* const*, char const*, char*&)
char getopt(int argc, char * const argv[], char const *optstr, char *&optarg) {
    static int optind = 1;
    if (optind >= argc || *argv[optind] != '-')
        return -1;
    auto opt = *(argv[optind++] + 1);
    auto p = strchr(optstr, opt);
    if (!p)
        return '?';
    if (p[1] == ':') {
        if (optind >= argc)
            return ':';
        optarg = argv[optind++];
    }
    return opt;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl 0x9d1b(%rip), %eax      # 0xc1e8
cmpl 0x30(%rsp), %eax
jge 0x24eb
movq 0x28(%rsp), %rax
movslq 0x9d09(%rip), %rcx      # 0xc1e8
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x24f5
movb $-0x1, 0x37(%rsp)
jmp 0x258a
movq 0x28(%rsp), %rax
movl 0x9ce8(%rip), %ecx      # 0xc1e8
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x9cdd(%rip)      # 0xc1e8
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movb 0x1(%rax), %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movsbl 0x17(%rsp), %esi
callq 0x20d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x253c
movb $0x3f, 0x37(%rsp)
jmp 0x258a
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3a, %eax
jne 0x2582
movl 0x9c98(%rip), %eax      # 0xc1e8
cmpl 0x30(%rsp), %eax
jl 0x255d
movb $0x3a, 0x37(%rsp)
jmp 0x258a
movq 0x28(%rsp), %rax
movl 0x9c80(%rip), %ecx      # 0xc1e8
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x9c75(%rip)      # 0xc1e8
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb 0x17(%rsp), %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)