LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Couragewang[P]50_clss/./TcpClient.hpp
// Function: TcpClient::Start()
void Start()
        {
            struct sockaddr_in peer;
            bzero(&peer, sizeof(peer));
            peer.sin_family = AF_INET;
            peer.sin_port = htons(port);
            peer.sin_addr.s_addr = inet_addr(ip.c_str());

            if(connect(sock, (struct sockaddr*)&peer, sizeof(peer)) < 0){
                std::cerr << "connect error" << std::endl;
                exit(3);
            }
            char buf[1024];
            std::string in;
            while(1){
                std::cout << "Please Enter# ";
                std::cin >> in;
                write(sock, in.c_str(), in.size());
                ssize_t s = read(sock, buf, sizeof(buf)-1);
                if(s > 0){
                    buf[s] = 0;
                    std::cout << "Server Echo# " << buf << std::endl;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp            # imm = 0x490
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x460(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x401060
movq -0x460(%rbp), %rax
movw $0x2, -0x18(%rbp)
movl 0x28(%rax), %eax
movzwl %ax, %edi
callq 0x52f7a0
movq -0x460(%rbp), %rdi
movw %ax, -0x16(%rbp)
addq $0x8, %rdi
callq 0x476950
movq %rax, %rdi
callq 0x52f9a0
movl %eax, %ecx
movq -0x460(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl (%rax), %edi
leaq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x52ed00
cmpl $0x0, %eax
jge 0x404b6b
movq $0x5e5320, %rdi         # imm = 0x5E5320
leaq 0x1724e3(%rip), %rsi    # 0x577030
callq 0x46eb40
movq %rax, %rdi
movq $0x46e420, %rsi         # imm = 0x46E420
callq 0x46d630
movl $0x3, %edi
callq 0x4c1e20
leaq -0x440(%rbp), %rdi
callq 0x474e00
jmp 0x404b79
movq $0x5e5440, %rdi         # imm = 0x5E5440
leaq 0x1724b7(%rip), %rsi    # 0x57703e
callq 0x46eb40
jmp 0x404b8e
movq $0x5e5560, %rdi         # imm = 0x5E5560
leaq -0x440(%rbp), %rsi
callq 0x406b10
jmp 0x404ba3
movq -0x460(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x46c(%rbp)
leaq -0x440(%rbp), %rdi
movq %rdi, -0x478(%rbp)
callq 0x476950
movq -0x478(%rbp), %rdi
movq %rax, -0x468(%rbp)
callq 0x475130
movl -0x46c(%rbp), %edi
movq -0x468(%rbp), %rsi
movq %rax, %rdx
callq 0x52bed0
jmp 0x404bef
movq -0x460(%rbp), %rax
movl (%rax), %edi
leaq -0x420(%rbp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x52be30
movq %rax, -0x480(%rbp)
jmp 0x404c12
movq -0x480(%rbp), %rax
movq %rax, -0x458(%rbp)
cmpq $0x0, -0x458(%rbp)
jle 0x404ca8
movq -0x458(%rbp), %rax
movb $0x0, -0x420(%rbp,%rax)
movq $0x5e5440, %rdi         # imm = 0x5E5440
leaq 0x172406(%rip), %rsi    # 0x57704d
callq 0x46eb40
movq %rax, -0x488(%rbp)
jmp 0x404c55
movq -0x488(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x46eb40
movq %rax, -0x490(%rbp)
jmp 0x404c71
movq -0x490(%rbp), %rdi
movq $0x46e420, %rsi         # imm = 0x46E420
callq 0x46d630
jmp 0x404c86
jmp 0x404ca8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x448(%rbp)
movl %eax, -0x44c(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x474f10
jmp 0x404cad
jmp 0x404b77
movq -0x448(%rbp), %rdi
callq 0x4a6550
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Sigma(gaps::R3Mesh*)
RNScalar
Sigma(R3Mesh *mesh)
{
  // Compute smallest sigma
  static RNScalar sigma = 0;
  static R3Mesh *last_mesh = NULL;
  if (mesh != last_mesh) {
    sigma = 0.005 * sqrt(mesh->Area());
    last_mesh = mesh;
  }

  // Return sigma
  return sigma;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq 0x1b5ec0(%rip), %rax    # 0x1ca720
je 0x14892
movq (%rsp), %rdi
callq 0x2f940
callq 0x114f0
movaps %xmm0, %xmm1
movsd 0x15f78d(%rip), %xmm0   # 0x174008
mulsd %xmm1, %xmm0
movsd %xmm0, 0x1b5e91(%rip)   # 0x1ca718
movq (%rsp), %rax
movq %rax, 0x1b5e8e(%rip)    # 0x1ca720
movsd 0x1b5e7e(%rip), %xmm0   # 0x1ca718
popq %rax
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: InsertProperty(gaps::R3MeshPropertySet*, gaps::R3MeshProperty*, int)
int 
InsertProperty(R3MeshPropertySet *properties, R3MeshProperty *property, int num_blurs = 0)
{
  // Insert property
  properties->Insert(property);

  // Insert coies of property with increasing blur
  if (num_blurs > 0) {
    char buffer[4096];
    RNScalar sigma = Sigma(properties->Mesh());
    R3MeshProperty *p = property;
    for (int i = 1; i < num_blurs; i++) {
      p = new R3MeshProperty(*p);
      sprintf(buffer, "%s%d", property->Name(), i);
      p->SetName(buffer);
      p->Blur(sigma);
      properties->Insert(p);
      sigma *= 2;
    }
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x1058, %rsp           # imm = 0x1058
movq %rdi, 0x1050(%rsp)
movq %rsi, 0x1048(%rsp)
movl %edx, 0x1044(%rsp)
movq 0x1050(%rsp), %rdi
movq 0x1048(%rsp), %rsi
callq 0x24e20
cmpl $0x0, 0x1044(%rsp)
jle 0x149f4
movq 0x1050(%rsp), %rdi
callq 0x1f260
movq %rax, %rdi
callq 0x14850
movsd %xmm0, 0x38(%rsp)
movq 0x1048(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x1, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x1044(%rsp), %eax
jge 0x149f2
movl $0x448, %edi            # imm = 0x448
callq 0x11680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rsi
callq 0x28100
jmp 0x14943
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1048(%rsp), %rdi
callq 0x1f270
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl 0x2c(%rsp), %ecx
leaq 0x15f749(%rip), %rsi    # 0x1740c0
movb $0x0, %al
callq 0x11120
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2b140
movq 0x30(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0x2ba30
movq 0x1050(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x24e20
movsd 0x15f659(%rip), %xmm0   # 0x174010
mulsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x14911
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x448, %esi            # imm = 0x448
callq 0x11690
jmp 0x14a01
jmp 0x149f4
movl $0x1, %eax
addq $0x1058, %rsp           # imm = 0x1058
retq
movq 0x20(%rsp), %rdi
callq 0x11bb0
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: main
int main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(1);

  // Read mesh file
  R3Mesh *mesh = ReadMesh(input_mesh_name);
  if (!mesh) exit(-1);

  // Compute property set
  R3MeshPropertySet *properties = ComputeProperties(mesh);
  if (!properties) exit(-1);

  // Write properties file
  if (!WriteProperties(properties, output_properties_name)) exit(-1);

  // Write mesh
  if (output_mesh_name) {
    if (!WriteMesh(mesh, output_mesh_name)) exit(-1);
  }

  // Return success 
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x14ae0
cmpl $0x0, %eax
jne 0x14a42
movl $0x1, %edi
callq 0x11820
movq 0x1b5cdf(%rip), %rdi    # 0x1ca728
callq 0x14fd0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x14a65
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11820
movq 0x10(%rsp), %rdi
callq 0x15130
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x14a86
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11820
movq 0x8(%rsp), %rdi
movq 0x1b5c9e(%rip), %rsi    # 0x1ca730
callq 0x157e0
cmpl $0x0, %eax
jne 0x14aa6
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11820
cmpq $0x0, 0x1b5c8a(%rip)    # 0x1ca738
je 0x14ad2
movq 0x10(%rsp), %rdi
movq 0x1b5c7c(%rip), %rsi    # 0x1ca738
callq 0x158c0
cmpl $0x0, %eax
jne 0x14ad0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11820
jmp 0x14ad2
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: ReadMesh(char*)
static R3Mesh *
ReadMesh(char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  assert(mesh);

  // Read mesh from file
  if (!mesh->ReadFile(filename)) {
    RNFail("Unable to read mesh from %s\n", filename);
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read mesh from %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return mesh;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xe98e0
movq (%rsp), %rdi
callq 0x1f280
movl $0x138, %edi            # imm = 0x138
callq 0x11680
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x2e720
jmp 0x1500c
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x180(%rax)
cmpl $0x0, %eax
jne 0x15071
movq 0x38(%rsp), %rsi
leaq 0x15f19e(%rip), %rdi    # 0x1741d8
movb $0x0, %al
callq 0xedb00
movq $0x0, 0x40(%rsp)
jmp 0x15110
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x138, %esi            # imm = 0x138
callq 0x11690
jmp 0x1511a
cmpl $0x0, 0x1b56c8(%rip)    # 0x1ca740
je 0x15106
movq 0x38(%rsp), %rsi
leaq 0x15f16b(%rip), %rdi    # 0x1741f5
movb $0x0, %al
callq 0x11090
leaq 0x28(%rsp), %rdi
callq 0xe99a0
leaq 0x15f16a(%rip), %rdi    # 0x17420c
movb $0x1, %al
callq 0x11090
movq 0x20(%rsp), %rdi
callq 0x1f2a0
movl %eax, %esi
leaq 0x15f167(%rip), %rdi    # 0x174223
movb $0x0, %al
callq 0x11090
movq 0x20(%rsp), %rdi
callq 0x1f2c0
movl %eax, %esi
leaq 0x15f15d(%rip), %rdi    # 0x174233
movb $0x0, %al
callq 0x11090
movq 0x20(%rsp), %rdi
callq 0x1f2e0
movl %eax, %esi
leaq 0x15f153(%rip), %rdi    # 0x174243
movb $0x0, %al
callq 0x11090
movq 0x1abe92(%rip), %rax    # 0x1c0f90
movq (%rax), %rdi
callq 0x117f0
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x11bb0
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: WriteProperties(gaps::R3MeshPropertySet*, char*)
static int
WriteProperties(R3MeshPropertySet *properties, char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write properties to file
  if (!properties->Write(filename)) {
    RNFail("Unable to write properties to %s\n", filename);
    return 0;
  }

  // Print statistics
  if (print_verbose) {
    printf("Wrote properties to %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Properties = %d\n", properties->NProperties());
    printf("  # Vertices = %d\n", properties->Mesh()->NVertices());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsp, %rdi
callq 0xe98e0
movq %rsp, %rdi
callq 0x1f280
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x27010
cmpl $0x0, %eax
jne 0x15832
movq 0x10(%rsp), %rsi
leaq 0x15f0a6(%rip), %rdi    # 0x1748c4
movb $0x0, %al
callq 0xedb00
movl $0x0, 0x24(%rsp)
jmp 0x158b7
cmpl $0x0, 0x1b4f07(%rip)    # 0x1ca740
je 0x158af
movq 0x10(%rsp), %rsi
leaq 0x15f09f(%rip), %rdi    # 0x1748e6
movb $0x0, %al
callq 0x11090
movq %rsp, %rdi
callq 0xe99a0
leaq 0x15e9af(%rip), %rdi    # 0x17420c
movb $0x1, %al
callq 0x11090
movq 0x18(%rsp), %rdi
callq 0x1f400
movl %eax, %esi
leaq 0x15ea40(%rip), %rdi    # 0x1742b7
movb $0x0, %al
callq 0x11090
movq 0x18(%rsp), %rdi
callq 0x1f260
movq %rax, %rdi
callq 0x1f2e0
movl %eax, %esi
leaq 0x15e9aa(%rip), %rdi    # 0x174243
movb $0x0, %al
callq 0x11090
movq 0x1ab6e9(%rip), %rax    # 0x1c0f90
movq (%rax), %rdi
callq 0x117f0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: proj_curv(gaps::R3Vector const&, gaps::R3Vector const&, double, double, double, gaps::R3Vector const&, gaps::R3Vector const&, double&, double&, double&)
static void proj_curv(const R3Vector &old_u, const R3Vector &old_v,
                      RNScalar old_ku, RNScalar old_kuv, RNScalar old_kv,
                      const R3Vector &new_u, const R3Vector &new_v,
                      RNScalar &new_ku, RNScalar &new_kuv, RNScalar &new_kv)
{
  R3Vector r_new_u, r_new_v;
  rot_coord_sys(new_u, new_v, old_u % old_v, r_new_u, r_new_v);

  RNScalar u1 = r_new_u.Dot(old_u);
  RNScalar v1 = r_new_u.Dot(old_v);
  RNScalar u2 = r_new_v.Dot(old_u);
  RNScalar v2 = r_new_v.Dot(old_v);
  new_ku  = old_ku * u1*u1 + old_kuv * (2.0  * u1*v1) + old_kv * v1*v1;
  new_kuv = old_ku * u1*u2 + old_kuv * (u1*v2 + u2*v1) + old_kv * v1*v2;
  new_kv  = old_ku * u2*u2 + old_kuv * (2.0  * u2*v2) + old_kv * v2*v2;
}

// Assembly:
subq $0xc8, %rsp
movq 0xd0(%rsp), %rax
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movsd %xmm0, 0xb0(%rsp)
movsd %xmm1, 0xa8(%rsp)
movsd %xmm2, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movq %r8, 0x88(%rsp)
movq %r9, 0x80(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x89430
leaq 0x50(%rsp), %rdi
callq 0x89430
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x8a280
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x1c840
movq 0xc0(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x89a50
movsd %xmm0, 0x30(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x89a50
movsd %xmm0, 0x28(%rsp)
movq 0xc0(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x89a50
movsd %xmm0, 0x20(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x89a50
movsd %xmm0, 0x18(%rsp)
movsd 0xb0(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0xa8(%rsp), %xmm0
movsd 0x157d1a(%rip), %xmm3   # 0x174010
mulsd 0x30(%rsp), %xmm3
mulsd 0x28(%rsp), %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa0(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x88(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0xb0(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0xa8(%rsp), %xmm0
movsd 0x30(%rsp), %xmm3
movsd 0x18(%rsp), %xmm5
movsd 0x20(%rsp), %xmm4
mulsd 0x28(%rsp), %xmm4
mulsd %xmm5, %xmm3
addsd %xmm4, %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa0(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x80(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0xb0(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0xa8(%rsp), %xmm0
movsd 0x157c40(%rip), %xmm3   # 0x174010
mulsd 0x20(%rsp), %xmm3
mulsd 0x18(%rsp), %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa0(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0xd0(%rsp), %rax
movsd %xmm0, (%rax)
addq $0xc8, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: rot_coord_sys(gaps::R3Vector const&, gaps::R3Vector const&, gaps::R3Vector const&, gaps::R3Vector&, gaps::R3Vector&)
static void rot_coord_sys(const R3Vector &old_u, const R3Vector &old_v,
			  const R3Vector &new_norm,
			  R3Vector &new_u, R3Vector &new_v)
{
  new_u = old_u;
  new_v = old_v;
  if (new_u.IsZero()) return;
  if (new_v.IsZero()) return;
  R3Vector old_norm = old_u % old_v;
  if (old_norm.IsZero()) return;
  RNScalar ndot = old_norm.Dot(new_norm);
  if (ndot >= 1.0) return;
  if (ndot <= -1.0) {
    new_u = -new_u;
    new_v = -new_v;
    return;
  }
  R3Vector perp_old = new_norm - ndot * old_norm;
  R3Vector dperp = 1.0f / (1 + ndot) * (old_norm + new_norm);
  new_u -= dperp * new_u.Dot(perp_old);
  new_v -= dperp * new_v.Dot(perp_old);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq %rcx, 0xf8(%rsp)
movq %r8, 0xf0(%rsp)
movq 0x110(%rsp), %rsi
movq 0xf8(%rsp), %rdi
callq 0x8a100
movq 0x108(%rsp), %rsi
movq 0xf0(%rsp), %rdi
callq 0x8a100
movq 0xf8(%rsp), %rdi
callq 0x1f7a0
cmpl $0x0, %eax
je 0x1c8b0
jmp 0x1ca9c
movq 0xf0(%rsp), %rdi
callq 0x1f7a0
cmpl $0x0, %eax
je 0x1c8c7
jmp 0x1ca9c
movq 0x110(%rsp), %rsi
movq 0x108(%rsp), %rdx
leaq 0xd8(%rsp), %rdi
callq 0x8a280
leaq 0xd8(%rsp), %rdi
callq 0x1f7a0
cmpl $0x0, %eax
je 0x1c8fb
jmp 0x1ca9c
movq 0x100(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x89a50
movsd %xmm0, 0xd0(%rsp)
movsd 0xd0(%rsp), %xmm0
movsd 0x1576ee(%rip), %xmm1   # 0x174018
ucomisd %xmm1, %xmm0
jb 0x1c935
jmp 0x1ca9c
movsd 0x1576fb(%rip), %xmm0   # 0x174038
ucomisd 0xd0(%rsp), %xmm0
jb 0x1c9a1
movq 0xf8(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x8a730
movq 0xf8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x8a100
movq 0xf0(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x8a730
movq 0xf0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x8a100
jmp 0x1ca9c
movq 0x100(%rsp), %rax
movq %rax, (%rsp)
movsd 0xd0(%rsp), %xmm0
leaq 0x70(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x1f810
movq (%rsp), %rsi
leaq 0x88(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x8a830
movsd 0x157632(%rip), %xmm1   # 0x174018
addsd 0xd0(%rsp), %xmm1
movsd 0x157621(%rip), %xmm0   # 0x174018
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x100(%rsp), %rdx
leaq 0x40(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x8a7c0
movsd 0x8(%rsp), %xmm0
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1f810
movq 0xf8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x89a50
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x8a310
movq 0xf8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8a3c0
movq 0xf0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x89a50
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x8a310
movq 0xf0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8a3c0
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Mean(double*, int)
static RNScalar
Mean(RNScalar *values, int nvalues)
{
  // Return mean
  if (nvalues == 0) return 0;
  RNScalar sum = 0;
  for (int i = 0; i < nvalues; i++) 
    sum += values[i];
  return sum / nvalues;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jne 0x1ce8b
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1cee4
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x1cece
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x20(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x1ce9c
movsd -0x20(%rsp), %xmm0
cvtsi2sdl -0x14(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: StandardDeviation(double*, int)
static RNScalar
StandardDeviation(RNScalar *values, int nvalues)
{
  // Return standard deviation
  if (nvalues == 0) return 0;
  RNScalar mean = Mean(values, nvalues);
  RNScalar ssd = 0;
  for (int i = 0; i < nvalues; i++) {
    RNScalar delta = values[i] - mean;
    ssd += delta * delta;
  }
  return sqrt(ssd / nvalues);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x1cf12
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x1cfa1
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1ce70
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x1cf86
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd (%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1cf37
movsd 0x10(%rsp), %xmm0
cvtsi2sdl 0x24(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x114f0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Percentile(double*, int, double)
static RNScalar
Percentile(RNScalar *values, int nvalues, RNScalar percentile)
{
  // Return value at given percentile (0-100)
  if (nvalues == 0) return 0;
  RNScalar *copy = new RNScalar [ nvalues ];
  for (int i = 0; i < nvalues; i++) copy[i] = values[i];
  qsort(copy, nvalues, sizeof(RNScalar), RNCompareScalars);
  int index = (int) (percentile * nvalues / 100.0);
  if (index >= nvalues) index = nvalues-1;
  RNScalar result = copy[index];
  delete [] copy;
  return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movsd %xmm0, 0x28(%rsp)
cmpl $0x0, 0x34(%rsp)
jne 0x1d008
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x1d0ff
movslq 0x34(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x11040
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x1d070
movq 0x38(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1d03b
movq 0x20(%rsp), %rdi
movslq 0x34(%rsp), %rsi
movl $0x8, %edx
leaq 0xd027a(%rip), %rcx     # 0xed300
callq 0x11cb0
movsd 0x28(%rsp), %xmm0
cvtsi2sdl 0x34(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x156fed(%rip), %xmm1   # 0x174090
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x34(%rsp), %eax
jl 0x1d0c4
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1d0f3
movq 0x8(%rsp), %rdi
callq 0x118b0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Maximum(double*, int)
static RNScalar
Maximum(RNScalar *values, int nvalues)
{
  // Return maximum of values
  if (nvalues == 0) return 0;
  RNScalar maximum = -FLT_MAX;
  for (int i = 0; i < nvalues; i++) {
    if (values[i] > maximum) maximum = values[i];
  }
  return maximum;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jne 0x1d12b
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rsp)
jmp 0x1d192
movsd 0x156f65(%rip), %xmm0   # 0x174098
movsd %xmm0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x1d186
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x20(%rsp), %xmm0
jbe 0x1d177
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rsp)
jmp 0x1d179
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x1d141
movsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
retq
nopl (%rax)
// File: marknelson[P]LZW/./lzw-d.h
// Function: lzw::output_code_stream<std::ostream>::operator<<(unsigned int const&)
void operator<<( const unsigned int &i )
    {
        m_pending_output |= i << m_pending_bits;
        m_pending_bits += m_code_size;
        flush( 8 );
        if ( m_current_code < m_max_code ) {
            m_current_code++;
            if ( m_current_code == m_next_bump ) {
                m_next_bump *= 2;
                m_code_size++;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl 0x10(%rdi), %ecx
shll %cl, %eax
orl 0x14(%rdi), %eax
movl %eax, 0x14(%rdi)
movl (%rdi), %eax
addl 0x10(%rdi), %eax
movl %eax, 0x10(%rdi)
movl $0x8, %esi
callq 0x55c0
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x20(%rcx), %eax
jae 0x34a1
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x18(%rcx)
movl 0x18(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x349f
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %ecx
shll %ecx
movl %ecx, 0x1c(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x34a1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: marknelson[P]LZW/./lzw-d.h
// Function: lzw::output_code_stream<std::ostream>::flush(int)
void flush( const int val )
    {
        while ( m_pending_bits >= val ) {
            m_output.put( m_pending_output & 0xff );
            m_pending_output >>= 8;
            m_pending_bits -= 8;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x5613
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x14(%rax), %eax
andl $0xff, %eax
movsbl %al, %esi
callq 0x2030
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
shrl $0x8, %ecx
movl %ecx, 0x14(%rax)
movl 0x10(%rax), %ecx
subl $0x8, %ecx
movl %ecx, 0x10(%rax)
jmp 0x55d7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: marknelson[P]LZW/./lzw-d.h
// Function: lzw::input_code_stream<std::istream>::operator>>(unsigned int&)
bool operator>>( unsigned int &i )
    {
        while ( m_available_bits < m_code_size )
        {
            char c;
            if ( !m_input.get(c) )
                return false;
            m_pending_input |= (c & 0xff) << m_available_bits;
            m_available_bits += 8;
        }
        i = m_pending_input & ~(~0 << m_code_size);
        m_pending_input >>= m_code_size;
        m_available_bits -= m_code_size;
        if ( m_current_code < m_max_code ) {
            m_current_code++;
            if ( m_current_code == m_next_bump ) {
                m_next_bump *= 2;
                m_code_size++;
            }
        }
        if ( i == EOF_CODE )
            return false;
        else
            return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %eax
cmpl (%rcx), %eax
jge 0x57f8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x19(%rbp), %rsi
callq 0x2230
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x20d0
testb $0x1, %al
jne 0x57c9
jmp 0x57d2
movb $0x0, -0x1(%rbp)
jmp 0x5875
movq -0x28(%rbp), %rax
movsbl -0x19(%rbp), %edx
andl $0xff, %edx
movl 0x10(%rax), %ecx
shll %cl, %edx
movl %edx, %ecx
orl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl 0x10(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x10(%rax)
jmp 0x5798
movq -0x28(%rbp), %rax
movl 0x14(%rax), %edx
movl (%rax), %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shll %cl, %esi
movl %esi, %ecx
xorl $-0x1, %ecx
andl %ecx, %edx
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movl (%rax), %ecx
movl 0x14(%rax), %eax
shrl %cl, %eax
movq -0x28(%rbp), %rcx
movl %eax, 0x14(%rcx)
movl (%rcx), %edx
movl 0x10(%rcx), %eax
subl %edx, %eax
movl %eax, 0x10(%rcx)
movl 0x18(%rcx), %eax
cmpl 0x20(%rcx), %eax
jae 0x585f
movq -0x28(%rbp), %rcx
movl 0x18(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x18(%rcx)
movl 0x18(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x585d
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %ecx
shll %ecx
movl %ecx, 0x1c(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x585f
movq -0x18(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jne 0x5871
movb $0x0, -0x1(%rbp)
jmp 0x5875
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::DiskSpaceWorker(uv_work_s*)
void DiskSpaceWorker(uv_work_t *request) {
        reqData_t *requestData = reinterpret_cast<reqData_t *>(request->data);

        // Call the Inner Function
        requestData->error = GetDiskSpace(
            requestData->diskPath,
            &(requestData->available),
            &(requestData->total),
            &(requestData->free)
         );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
addq $0x28, %rdx
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
callq 0x2230
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::init(v8::Local<v8::Object>)
void init(Local<Object> exports) {
        NODE_SET_METHOD(exports, "check", DiskSpace);
        NODE_SET_METHOD(exports, "isErrDenied", nodeIsErrDenied);
        NODE_SET_METHOD(exports, "isErrBadPath", nodeIsErrBadPath);
        NODE_SET_METHOD(exports, "isErrIO", nodeIsErrIO);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x905(%rip), %rsi       # 0x50d4
movq 0x27ea(%rip), %rdx      # 0x6fc0
callq 0x22f0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x8ec(%rip), %rsi       # 0x50da
movq 0x27c3(%rip), %rdx      # 0x6fb8
callq 0x22f0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x8d9(%rip), %rsi       # 0x50e6
movq 0x27e4(%rip), %rdx      # 0x6ff8
callq 0x22f0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x8c7(%rip), %rsi       # 0x50f3
movq 0x2765(%rip), %rdx      # 0x6f98
callq 0x22f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Saevon[P]node-diskfree/build/../src/disk.cpp
// Function: isErrBadPath(unsigned long)
bool isErrBadPath(uint64_t error) {
    return (false
        #ifdef IS_UNIX
            // Path doesn't exist
            || error == ENOENT
            // Path has too many redirects
            || error == ELOOP
            // Path is too long
            || error == ENAMETOOLONG
            // Not a directory
            || error == ENOTDIR
        #endif
        #ifdef IS_WIN
            // Path doesn't exist
            || error == ERROR_PATH_NOT_FOUND
            // Drive doesn't exist
            || error == ERROR_INVALID_DRIVE
        #endif
    );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movb $0x1, %al
cmpq $0x2, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x4cc7
movb $0x1, %al
cmpq $0x28, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x4cc7
movb $0x1, %al
cmpq $0x24, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x4cc7
cmpq $0x14, -0x8(%rbp)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: fiveseven-lambda[P]michaelis-menten/a.cpp
// Function: object::node::find(Vector<short> const&)
void node::find(const Vector<short> &p){
		focused = nodes.size();
		double min = std::numeric_limits<double>::max();
		for(std::size_t i = 0; i < nodes.size(); ++i){
			Arc arc = nodes[i].arc();
			if((arc.x - p.x) * (arc.x - p.x) + (arc.y - p.y) * (arc.y - p.y) < arc.r * arc.r && min > nodes[i].am){
				focused = i;
				min = nodes[i].am;
			}
		}
		edge::focused = edge::edges.size();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd4b5(%rip), %rdi      # 0x101d8
callq 0x5590
movq %rax, 0xd4c1(%rip)      # 0x101f0
callq 0x55b0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xd488(%rip), %rdi      # 0x101d8
callq 0x5590
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x2e33
movq -0x18(%rbp), %rsi
leaq 0xd468(%rip), %rdi      # 0x101d8
callq 0x55c0
movq %rax, %rdi
callq 0x55e0
movl %eax, %ecx
movl %ecx, -0x1e(%rbp)
shrq $0x20, %rax
movw %ax, -0x1a(%rbp)
movswl -0x1e(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl (%rcx), %ecx
subl %ecx, %eax
movswl -0x1e(%rbp), %ecx
movq -0x8(%rbp), %rdx
movswl (%rdx), %edx
subl %edx, %ecx
imull %ecx, %eax
movswl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rdx
movswl 0x2(%rdx), %edx
subl %edx, %ecx
movswl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rsi
movswl 0x2(%rsi), %esi
subl %esi, %edx
imull %edx, %ecx
addl %ecx, %eax
movzwl -0x1a(%rbp), %ecx
movzwl -0x1a(%rbp), %edx
imull %edx, %ecx
cmpl %ecx, %eax
jge 0x2e20
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xd3ec(%rip), %rdi      # 0x101d8
callq 0x55c0
movsd -0x30(%rbp), %xmm0
ucomisd (%rax), %xmm0
jbe 0x2e20
movq -0x18(%rbp), %rax
movq %rax, 0xd3e9(%rip)      # 0x101f0
movq -0x18(%rbp), %rsi
leaq 0xd3c6(%rip), %rdi      # 0x101d8
callq 0x55c0
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x2e22
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2d41
leaq 0xd3c6(%rip), %rdi      # 0x10200
callq 0x5670
movq %rax, 0xd3d2(%rip)      # 0x10218
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: fiveseven-lambda[P]michaelis-menten/a.cpp
// Function: object::edge::find(Vector<short> const&)
void edge::find(const Vector<short> &p){
		focused = edges.size();
		double min = std::numeric_limits<double>::max();
		for(std::size_t i = 0; i < edges.size(); ++i){
			if(min > edges[i].k && [&]() -> bool {
				for(std::size_t j : edges[i].from){
					if(in_polygon(p, bezier(edges[i].mid, node::nodes[j].p, edges[i].pre, edges[i].k * scale))){
						return true;
					}
				}
				for(std::size_t j : edges[i].to){
					if(in_polygon(p, bezier(edges[i].mid, node::nodes[j].p, edges[i].post, edges[i].k * scale))){
						return true;
					}
				}
				return false;
			}()){
				focused = i;
				min = edges[i].k;
			}
		}
		node::focused = node::nodes.size();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd39d(%rip), %rdi      # 0x10200
callq 0x5670
movq %rax, 0xd3a9(%rip)      # 0x10218
callq 0x55b0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xd370(%rip), %rdi      # 0x10200
callq 0x5670
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f30
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xd346(%rip), %rdi      # 0x10200
callq 0x56a0
movsd -0x40(%rbp), %xmm0
movq %rax, %rcx
xorl %eax, %eax
ucomisd 0x30(%rcx), %xmm0
movb %al, -0x31(%rbp)
jbe 0x2eef
leaq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f50
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2ef8
jmp 0x2f1d
movq -0x18(%rbp), %rax
movq %rax, 0xd315(%rip)      # 0x10218
movq -0x18(%rbp), %rsi
leaq 0xd2f2(%rip), %rdi      # 0x10200
callq 0x56a0
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x2f1f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2e81
leaq 0xd2a1(%rip), %rdi      # 0x101d8
callq 0x5590
movq %rax, 0xd2ad(%rip)      # 0x101f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sbingner[P]kerneldec/lzfse/src/lzfse_main.c
// Function: usage
void usage(int argc, char **argv) {
  fprintf(
      stderr,
      "Usage: %s -encode|-decode [-i input_file] [-o output_file] [-h] [-v]\n",
      argv[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xfda2(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xbda9(%rip), %rsi      # 0xf010
movb $0x0, %al
callq 0x30b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sbingner[P]kerneldec/lzfse/src/lzfse_main.c
// Function: get_time
static double get_time() {
#if defined(_MSC_VER)
  LARGE_INTEGER count, freq;
  if (QueryPerformanceFrequency(&freq) && QueryPerformanceCounter(&count)) {
    return (double)count.QuadPart / (double)freq.QuadPart;
  }
  return 1.0e-3 * (double)GetTickCount();
#else
  struct timeval tv;
  if (gettimeofday(&tv, 0) != 0) {
    perror("gettimeofday");
    exit(1);
  }
  return (double)tv.tv_sec + 1.0e-6 * (double)tv.tv_usec;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3060
cmpl $0x0, %eax
je 0x3720
leaq 0xba17(%rip), %rdi      # 0xf128
callq 0x3110
movl $0x1, %edi
callq 0x3120
cvtsi2sdq -0x10(%rbp), %xmm1
cvtsi2sdq -0x8(%rbp), %xmm0
movsd 0xb8d4(%rip), %xmm2     # 0xf008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sbingner[P]kerneldec/lzfse/src/lzfse_encode.c
// Function: lzfse_encode_buffer
size_t lzfse_encode_buffer(uint8_t *__restrict dst_buffer, size_t dst_size,
                           const uint8_t *__restrict src_buffer,
                           size_t src_size, void *__restrict scratch_buffer) {
  int has_malloc = 0;
  size_t ret = 0;

  // Deal with the possible NULL pointer
  if (scratch_buffer == NULL) {
    // +1 in case scratch size could be zero
    scratch_buffer = malloc(lzfse_encode_scratch_size() + 1);
    has_malloc = 1;
  }
  if (scratch_buffer == NULL)
    return 0;
  ret = lzfse_encode_buffer_with_scratch(dst_buffer, 
                        dst_size, src_buffer, 
                        src_size, scratch_buffer);
  if (has_malloc)
    free(scratch_buffer);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3afe
callq 0x3750
movq %rax, %rdi
addq $0x1, %rdi
callq 0x30d0
movq %rax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3b0f
movq $0x0, -0x8(%rbp)
jmp 0x3b43
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3790
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x3b3b
movq -0x30(%rbp), %rdi
callq 0x3030
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sbingner[P]kerneldec/lzfse/src/lzfse_decode.c
// Function: lzfse_decode_buffer_with_scratch
size_t lzfse_decode_buffer_with_scratch(uint8_t *__restrict dst_buffer, 
                         size_t dst_size, const uint8_t *__restrict src_buffer,
                         size_t src_size, void *__restrict scratch_buffer) {
  lzfse_decoder_state *s = (lzfse_decoder_state *)scratch_buffer;
  memset(s, 0x00, sizeof(*s));

  // Initialize state
  s->src = src_buffer;
  s->src_begin = src_buffer;
  s->src_end = s->src + src_size;
  s->dst = dst_buffer;
  s->dst_begin = dst_buffer;
  s->dst_end = dst_buffer + dst_size;

  // Decode
  int status = lzfse_decode(s);
  if (status == LZFSE_STATUS_DST_FULL)
    return dst_size;
  if (status != LZFSE_STATUS_OK)
    return 0;                           // failed
  return (size_t)(s->dst - dst_buffer); // bytes written
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0xb920, %edx           # imm = 0xB920
callq 0x3080
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
addq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rdi
callq 0x7870
movl %eax, -0x3c(%rbp)
cmpl $-0x2, -0x3c(%rbp)
jne 0x3c02
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c25
cmpl $0x0, -0x3c(%rbp)
je 0x3c12
movq $0x0, -0x8(%rbp)
jmp 0x3c25
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: sbingner[P]kerneldec/lzfse/src/lzfse_decode.c
// Function: lzfse_decode_buffer
size_t lzfse_decode_buffer(uint8_t *__restrict dst_buffer, size_t dst_size,
                           const uint8_t *__restrict src_buffer,
                           size_t src_size, void *__restrict scratch_buffer) {
  int has_malloc = 0;
  size_t ret = 0;

  // Deal with the possible NULL pointer
  if (scratch_buffer == NULL) {
    // +1 in case scratch size could be zero
    scratch_buffer = malloc(lzfse_decode_scratch_size() + 1);
    has_malloc = 1;
  }
  if (scratch_buffer == NULL)
    return 0;
  ret = lzfse_decode_buffer_with_scratch(dst_buffer, 
                               dst_size, src_buffer, 
                               src_size, scratch_buffer);
  if (has_malloc)
    free(scratch_buffer);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x41fe
callq 0x3b50
movq %rax, %rdi
addq $0x1, %rdi
callq 0x30d0
movq %rax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x420f
movq $0x0, -0x8(%rbp)
jmp 0x4243
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3b60
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x423b
movq -0x30(%rbp), %rdi
callq 0x3030
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sbingner[P]kerneldec/lzfse/src/lzfse_decode.c
// Function: lzfse_decode_file
size_t lzfse_decode_file(FILE *dst_file, FILE *src_file, size_t src_size,
                         int *error, void *__restrict scratch_buffer) {
  int has_malloc = 0;
  size_t ret = 0;

  // Deal with the possible NULL pointer
  if (scratch_buffer == NULL) {
    // +1 in case scratch size could be zero
    scratch_buffer = malloc(lzfse_decode_scratch_size() + 1);
    has_malloc = 1;
  }
  if (scratch_buffer == NULL) {
    if (error != NULL) *error = 1;
    return 0;
  }
  ret = lzfse_decode_file_with_scratch(dst_file, src_file, src_size, error, scratch_buffer);
  if (has_malloc)
    free(scratch_buffer);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x429e
callq 0x3b50
movq %rax, %rdi
addq $0x1, %rdi
callq 0x30d0
movq %rax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x42c0
cmpq $0x0, -0x28(%rbp)
je 0x42b6
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x42f4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3c30
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x42ec
movq -0x30(%rbp), %rdi
callq 0x3030
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: sbingner[P]kerneldec/lzfse/src/lzfse_encode_base.c
// Function: lzfse_encode_init
int lzfse_encode_init(lzfse_encoder_state *s) {
  const lzfse_match NO_MATCH = {0};
  lzfse_history_set line;
  for (int i = 0; i < LZFSE_ENCODE_HASH_WIDTH; i++) {
    line.pos[i] = -4 * LZFSE_ENCODE_MAX_D_VALUE; // invalid pos
    line.value[i] = 0;
  }
  // Fill table
  for (int i = 0; i < LZFSE_ENCODE_HASH_VALUES; i++)
    s->history_table[i] = line;
  s->pending = NO_MATCH;
  s->src_literal = 0;

  return LZFSE_STATUS_OK; // OK
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3080
movl $0x0, -0x44(%rbp)
cmpl $0x4, -0x44(%rbp)
jge 0x434c
movslq -0x44(%rbp), %rax
movl $0xfff00014, -0x40(%rbp,%rax,4) # imm = 0xFFF00014
movslq -0x44(%rbp), %rax
movl $0x0, -0x30(%rbp,%rax,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4323
movl $0x0, -0x48(%rbp)
cmpl $0x4000, -0x48(%rbp)    # imm = 0x4000
jge 0x439b
movq -0x8(%rbp), %rax
addq $0x27160, %rax          # imm = 0x27160
movslq -0x48(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x4353
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sbingner[P]kerneldec/lzfse/src/lzfse_encode_base.c
// Function: lzfse_encode_translate
int lzfse_encode_translate(lzfse_encoder_state *s, lzfse_offset delta) {
  assert(delta >= 0);
  if (delta == 0)
    return LZFSE_STATUS_OK; // OK

  // SRC
  s->src += delta;

  // Offsets in SRC
  s->src_end -= delta;
  s->src_encode_i -= delta;
  s->src_encode_end -= delta;
  s->src_literal -= delta;

  // Pending match
  s->pending.pos -= delta;
  s->pending.ref -= delta;

  // history_table positions, translated, and clamped to invalid pos
  int32_t invalidPos = -4 * LZFSE_ENCODE_MAX_D_VALUE;
  for (int i = 0; i < LZFSE_ENCODE_HASH_VALUES; i++) {
    int32_t *p = &(s->history_table[i].pos[0]);
    for (int j = 0; j < LZFSE_ENCODE_HASH_WIDTH; j++) {
      lzfse_offset newPos = p[j] - delta; // translate
      p[j] = (int32_t)((newPos < invalidPos) ? invalidPos : newPos); // clamp
    }
  }

  return LZFSE_STATUS_OK; // OK
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x43e9
jmp 0x4408
leaq 0xc1d5(%rip), %rdi      # 0x105c5
leaq 0xc1d9(%rip), %rsi      # 0x105d0
movl $0x262, %edx            # imm = 0x262
leaq 0xc1e5(%rip), %rcx      # 0x105e8
callq 0x3070
cmpq $0x0, -0x18(%rbp)
jne 0x441b
movl $0x0, -0x4(%rbp)
jmp 0x4542
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x48(%rax)
movl $0xfff00014, -0x1c(%rbp) # imm = 0xFFF00014
movl $0x0, -0x20(%rbp)
cmpl $0x4000, -0x20(%rbp)    # imm = 0x4000
jge 0x453b
movq -0x10(%rbp), %rax
addq $0x27160, %rax          # imm = 0x27160
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jge 0x452b
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
jge 0x4507
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x450f
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl %eax, %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x44d6
jmp 0x452d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x44a9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sbingner[P]kerneldec/lzfse/src/lzfse_encode_base.c
// Function: lzfse_backend_match
static int lzfse_backend_match(lzfse_encoder_state *s,
                               const lzfse_match *match) {
  // Try to push the match in state
  if (lzfse_push_match(s, match) == LZFSE_STATUS_OK)
    return LZFSE_STATUS_OK; // OK, match added to state

  // Here state tables are full, try to emit block
  if (lzfse_encode_matches(s) != LZFSE_STATUS_OK)
    return LZFSE_STATUS_DST_FULL; // DST full, match not added

  // Here block has been emitted, re-try to push the match in state
  return lzfse_push_match(s, match);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4df0
cmpl $0x0, %eax
jne 0x4c2b
movl $0x0, -0x4(%rbp)
jmp 0x4c52
movq -0x10(%rbp), %rdi
callq 0x4f50
cmpl $0x0, %eax
je 0x4c42
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x4c52
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4df0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)