LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ClipperOffset::FixOrientations()
void ClipperOffset::FixOrientations()
{
  //fixup orientations of all closed paths if the orientation of the
  //closed path with the lowermost vertex is wrong ...
  if (m_lowest.X >= 0 && 
    !Orientation(m_polyNodes.Childs[(int)m_lowest.X]->Contour))
  {
    for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    {
      PolyNode& node = *m_polyNodes.Childs[i];
      if (node.m_endtype == etClosedPolygon ||
        (node.m_endtype == etClosedLine && Orientation(node.Contour)))
          ReversePath(node.Contour);
    }
  } else
  {
    for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
    {
      PolyNode& node = *m_polyNodes.Childs[i];
      if (node.m_endtype == etClosedLine && !Orientation(node.Contour))
        ReversePath(node.Contour);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0xa0(%rax)
jl 0x1c243
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0xb0, %rdi
addq $0x18, %rdi
movq 0xa0(%rax), %rax
movslq %eax, %rsi
callq 0x20200
movq (%rax), %rdi
callq 0x10fa0
testb $0x1, %al
jne 0x1c243
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
addq $0xb0, %rdi
callq 0x10c70
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x1c241
movq -0x30(%rbp), %rdi
addq $0xb0, %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x20200
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x1c22b
movq -0x18(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1c234
movq -0x18(%rbp), %rdi
callq 0x10fa0
testb $0x1, %al
jne 0x1c22b
jmp 0x1c234
movq -0x18(%rbp), %rdi
callq 0x1c2c0
jmp 0x1c236
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c1ca
jmp 0x1c2b7
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
addq $0xb0, %rdi
callq 0x10c70
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jge 0x1c2b5
movq -0x30(%rbp), %rdi
addq $0xb0, %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x20200
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1c2a8
movq -0x28(%rbp), %rdi
callq 0x10fa0
testb $0x1, %al
jne 0x1c2a8
movq -0x28(%rbp), %rdi
callq 0x1c2c0
jmp 0x1c2aa
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1c24a
jmp 0x1c2b7
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::SimplifyPolygon(std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>> const&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&, ClipperLib::PolyFillType)
void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType)
{
  Clipper c;
  c.StrictlySimple(true);
  c.AddPath(in_poly, ptSubject, true);
  c.Execute(ctUnion, out_polys, fillType, fillType);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x118(%rbp), %rdi
movq %rdi, -0x130(%rbp)
xorl %esi, %esi
callq 0x14780
movq -0x130(%rbp), %rdi
movl $0x1, %esi
callq 0x21e00
jmp 0x1eb8e
movq -0x118(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x118(%rbp,%rax), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x13670
jmp 0x1ebb3
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %r8d
leaq -0x118(%rbp), %rdi
movl $0x1, %esi
movl %r8d, %ecx
callq 0x14ad0
jmp 0x1ebd1
leaq -0x118(%rbp), %rdi
callq 0x14940
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x14940
movq -0x120(%rbp), %rdi
callq 0x3440
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::SimplifyPolygons(std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>> const&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&, ClipperLib::PolyFillType)
void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType)
{
  Clipper c;
  c.StrictlySimple(true);
  c.AddPaths(in_polys, ptSubject, true);
  c.Execute(ctUnion, out_polys, fillType, fillType);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x118(%rbp), %rdi
movq %rdi, -0x130(%rbp)
xorl %esi, %esi
callq 0x14780
movq -0x130(%rbp), %rdi
movl $0x1, %esi
callq 0x21e00
jmp 0x1ec4e
movq -0x118(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x118(%rbp,%rax), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x141c0
jmp 0x1ec73
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %r8d
leaq -0x118(%rbp), %rdi
movl $0x1, %esi
movl %r8d, %ecx
callq 0x14ad0
jmp 0x1ec91
leaq -0x118(%rbp), %rdi
callq 0x14940
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x14940
movq -0x120(%rbp), %rdi
callq 0x3440
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::DistanceFromLineSqrd(ClipperLib::IntPoint const&, ClipperLib::IntPoint const&, ClipperLib::IntPoint const&)
double DistanceFromLineSqrd(
  const IntPoint& pt, const IntPoint& ln1, const IntPoint& ln2)
{
  //The equation of a line in general form (Ax + By + C = 0)
  //given 2 points (x�,y�) & (x�,y�) is ...
  //(y� - y�)x + (x� - x�)y + (y� - y�)x� - (x� - x�)y� = 0
  //A = (y� - y�); B = (x� - x�); C = (y� - y�)x� - (x� - x�)y�
  //perpendicular distance of point (x�,y�) = (Ax� + By� + C)/Sqrt(A� + B�)
  //see http://en.wikipedia.org/wiki/Perpendicular_distance
  double A = double(ln1.Y - ln2.Y);
  double B = double(ln2.X - ln1.X);
  double C = A * ln1.X  + B * ln1.Y;
  C = A * pt.X + B * pt.Y - C;
  return (C * C) / (A * A + B * B);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq 0x8(%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
cvtsi2sdq (%rax), %xmm2
movsd -0x28(%rbp), %xmm1
movq -0x10(%rbp), %rax
cvtsi2sdq 0x8(%rax), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdq (%rax), %xmm2
movsd -0x28(%rbp), %xmm1
movq -0x8(%rbp), %rax
cvtsi2sdq 0x8(%rax), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x20(%rbp), %xmm3
movsd -0x28(%rbp), %xmm2
mulsd -0x28(%rbp), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nop
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::ExcludeOp(ClipperLib::OutPt*)
OutPt* ExcludeOp(OutPt* op)
{
  OutPt* result = op->Prev;
  result->Next = op->Next;
  op->Next->Prev = result;
  result->Idx = 0;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::MinkowskiSum(std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>> const&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>> const&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&, ClipperLib::PolyFillType, bool)
void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, 
    PolyFillType pathFillType, bool pathIsClosed)
{
  Clipper c;
  for (size_t i = 0; i < paths.size(); ++i)
  {
    Paths tmp;
    Minkowski(pattern, paths[i], tmp, true, pathIsClosed);
    c.AddPaths(tmp, ptSubject, true);
  }
  if (pathIsClosed) c.AddPaths(paths, ptClip, true);
  c.Execute(ctUnion, solution, pathFillType, pathFillType);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
callq 0x14780
movq $0x0, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb30
movq %rax, %rcx
movq -0x158(%rbp), %rax
cmpq %rcx, %rax
jae 0x1fc14
leaq -0x140(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0xcb10
movq -0x8(%rbp), %rax
movq %rax, -0x168(%rbp)
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x20a60
movq -0x168(%rbp), %rdi
movq -0x160(%rbp), %rdx
movq %rax, %rsi
movzbl -0x1d(%rbp), %r8d
andl $0x1, %r8d
movl $0x1, %ecx
callq 0x1f3e0
jmp 0x1fba9
movq -0x120(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x120(%rbp,%rax), %rdi
leaq -0x140(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x141c0
jmp 0x1fbd1
leaq -0x140(%rbp), %rdi
callq 0xcf90
movq -0x128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x128(%rbp)
jmp 0x1fb2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
leaq -0x140(%rbp), %rdi
callq 0xcf90
jmp 0x1fc88
testb $0x1, -0x1d(%rbp)
je 0x1fc55
movq -0x120(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x120(%rbp,%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x141c0
jmp 0x1fc3f
jmp 0x1fc55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
jmp 0x1fc88
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %r8d
leaq -0x120(%rbp), %rdi
movl $0x1, %esi
movl %r8d, %ecx
callq 0x14ad0
jmp 0x1fc73
leaq -0x120(%rbp), %rdi
callq 0x14940
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
leaq -0x120(%rbp), %rdi
callq 0x14940
movq -0x148(%rbp), %rdi
callq 0x3440
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::AddPolyNodeToPolygons(ClipperLib::PolyNode const&, ClipperLib::NodeType, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&)
void AddPolyNodeToPolygons(const PolyNode& polynode, NodeType nodetype, Paths& paths)
{
  bool match = true;
  if (nodetype == ntClosed) match = !polynode.IsOpen();
  else if (nodetype == ntOpen) return;

  if (!polynode.Contour.empty() && match)
    paths.push_back(polynode.Contour);
  for (int i = 0; i < polynode.ChildCount(); ++i)
    AddPolyNodeToPolygons(*polynode.Childs[i], nodetype, paths);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x1fd0f
movq -0x8(%rbp), %rdi
callq 0x10e20
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x1fd19
cmpl $0x1, -0xc(%rbp)
jne 0x1fd17
jmp 0x1fd83
jmp 0x1fd19
movq -0x8(%rbp), %rdi
callq 0x21ec0
testb $0x1, %al
jne 0x1fd39
testb $0x1, -0x19(%rbp)
je 0x1fd39
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x21670
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c70
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x1fd83
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movslq -0x20(%rbp), %rsi
callq 0x20320
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1fce0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1fd40
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::OpenPathsFromPolyTree(ClipperLib::PolyTree&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>>&)
void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths)
{
  paths.resize(0); 
  paths.reserve(polytree.Total());
  //Open paths are top level only, so ...
  for (int i = 0; i < polytree.ChildCount(); ++i)
    if (polytree.Childs[i]->IsOpen())
      paths.push_back(polytree.Childs[i]->Contour);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20cc0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10bf0
movq -0x20(%rbp), %rdi
movslq %eax, %rsi
callq 0x21400
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c70
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x1feea
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x20200
movq (%rax), %rdi
callq 0x10e20
testb $0x1, %al
jne 0x1feb8
jmp 0x1fedd
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x20200
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x21670
jmp 0x1fedf
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1fe81
addq $0x30, %rsp
popq %rbp
retq
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::operator<<(std::ostream&, std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>> const&)
std::ostream& operator <<(std::ostream &s, const Path &p)
{
  if (p.empty()) return s;
  Path::size_type last = p.size() -1;
  for (Path::size_type i = 0; i < last; i++)
    s << "(" << p[i].X << "," << p[i].Y << "), ";
  s << "(" << p[last].X << "," << p[last].Y << ")\n";
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21ec0
testb $0x1, %al
jne 0x1ff7f
jmp 0x1ff8c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2009a
movq -0x18(%rbp), %rdi
callq 0xd900
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x20029
movq -0x10(%rbp), %rdi
leaq 0xc870(%rip), %rsi      # 0x2c82a
callq 0x3260
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x20460
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x3130
movq %rax, %rdi
leaq 0xc846(%rip), %rsi      # 0x2c82c
callq 0x3260
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x20460
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x3130
movq %rax, %rdi
leaq 0xc81b(%rip), %rsi      # 0x2c82e
callq 0x3260
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1ffa5
movq -0x10(%rbp), %rdi
leaq 0xc7f6(%rip), %rsi      # 0x2c82a
callq 0x3260
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x20460
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x3130
movq %rax, %rdi
leaq 0xc7cc(%rip), %rsi      # 0x2c82c
callq 0x3260
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x20460
movq -0x40(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x3130
movq %rax, %rdi
leaq 0xc613(%rip), %rsi      # 0x2c6a0
callq 0x3260
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::operator<<(std::ostream&, std::vector<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>, std::allocator<std::vector<ClipperLib::IntPoint, std::allocator<ClipperLib::IntPoint>>>> const&)
std::ostream& operator <<(std::ostream &s, const Paths &p)
{
  for (Paths::size_type i = 0; i < p.size(); i++)
    s << p[i];
  s << "\n";
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcb30
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x20114
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20a60
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1ff60
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x200c8
movq -0x8(%rbp), %rdi
leaq 0xbeea(%rip), %rsi      # 0x2c009
callq 0x3260
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::SetDx(ClipperLib::TEdge&)
inline void SetDx(TEdge &e)
{
  e.Delta.X = (e.Top.X - e.Bot.X);
  e.Delta.Y = (e.Top.Y - e.Bot.Y);

  if (e.Delta.Y == 0) e.Dx = HORIZONTAL;
  else e.Dx = (double)(e.Delta.X) / e.Delta.Y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
subq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x20655
movq -0x8(%rbp), %rax
movsd 0xc05a(%rip), %xmm0     # 0x2c6a8
movsd %xmm0, 0x40(%rax)
jmp 0x20676
movq -0x8(%rbp), %rax
cvtsi2sdq 0x30(%rax), %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdq 0x38(%rax), %xmm1
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::InitEdge(ClipperLib::TEdge*, ClipperLib::TEdge*, ClipperLib::TEdge*, ClipperLib::IntPoint const&)
inline void InitEdge(TEdge* e, TEdge* eNext, TEdge* ePrev, const IntPoint& Pt)
{
  std::memset(e, 0, sizeof(TEdge));
  e->Next = eNext;
  e->Prev = ePrev;
  e->Curr = Pt;
  e->OutIdx = Unassigned;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x3140
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x5c(%rax) # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::E2InsertsBeforeE1(ClipperLib::TEdge&, ClipperLib::TEdge&)
inline bool E2InsertsBeforeE1(TEdge &e1, TEdge &e2)
{
  if (e2.Curr.X == e1.Curr.X) 
  {
    if (e2.Top.Y > e1.Top.Y)
      return e2.Top.X < TopX(e1, e2.Top.Y); 
      else return e1.Top.X > TopX(e2, e1.Top.Y);
  } 
  else return e2.Curr.X < e1.Curr.X;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x21966
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jle 0x21935
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x20580
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2197e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x20580
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2197e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]gcode-multi-shell-extrude/third_party/clipper.cpp
// Function: ClipperLib::UpdateOutPtIdxs(ClipperLib::OutRec&)
inline void UpdateOutPtIdxs(OutRec& outrec)
{  
  OutPt* op = outrec.Pts;
  do
  {
    op->Idx = outrec.Idx;
    op = op->Prev;
  }
  while(op != outrec.Pts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x219a4
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/gen-psqr.c
// Function: f_cmp_divisor
int
f_cmp_divisor (const void *parg, const void *qarg)
{
  const struct factor_t *p, *q;
  p = (const struct factor_t *) parg;
  q = (const struct factor_t *) qarg;
  if (p->divisor > q->divisor)
    return 1;
  else if (p->divisor < q->divisor)
    return -1;
  else
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xb873
movl $0x1, -0x4(%rbp)
jmp 0xb891
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xb88a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb891
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/gen-psqr.c
// Function: f_cmp_fraction
int
f_cmp_fraction (const void *parg, const void *qarg)
{
  const struct factor_t *p, *q;
  p = (const struct factor_t *) parg;
  q = (const struct factor_t *) qarg;
  if (p->fraction > q->fraction)
    return 1;
  else if (p->fraction < q->fraction)
    return -1;
  else
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsd 0x28(%rax), %xmm0
movq -0x28(%rbp), %rax
ucomisd 0x28(%rax), %xmm0
jbe 0xb8d9
movl $0x1, -0x4(%rbp)
jmp 0xb901
movq -0x20(%rbp), %rax
movsd 0x28(%rax), %xmm1
movq -0x28(%rbp), %rax
movsd 0x28(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb8fa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb901
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/gen-psqr.c
// Function: square_mask
void
square_mask (mpz_t mask, int m)
{
  int    p, i, r, idx;

  p = mul_2exp_mod (1, mod_bits, m);
  p = neg_mod (p, m);

  mpz_set_ui (mask, 0L);
  for (i = 0; i < m; i++)
    {
      r = (i * i) % m;
      idx = (r * p) % m;
      mpz_setbit (mask, (unsigned long) idx);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x771b(%rip), %esi      # 0x130d0
movl -0xc(%rbp), %edx
movl $0x1, %edi
callq 0xb910
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0xb940
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3390
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xba23
movl -0x14(%rbp), %eax
imull -0x14(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
imull -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x7460
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb9e7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/gen-psqr.c
// Function: generate_sq_res_0x100
void
generate_sq_res_0x100 (int limb_bits)
{
  int  i, res;

  nsq_res_0x100 = (0x100 + limb_bits - 1) / limb_bits;
  sq_res_0x100 = (mpz_t *) xmalloc (nsq_res_0x100 * sizeof (*sq_res_0x100));

  for (i = 0; i < nsq_res_0x100; i++)
    mpz_init_set_ui (sq_res_0x100[i], 0L);

  for (i = 0; i < 0x100; i++)
    {
      res = (i * i) % 0x100;
      mpz_setbit (sq_res_0x100[res / limb_bits],
                  (unsigned long) (res % limb_bits));
    }

  sq_res_0x100_num = 0;
  for (i = 0; i < nsq_res_0x100; i++)
    sq_res_0x100_num += mpz_popcount (sq_res_0x100[i]);
  sq_res_0x100_fraction = (double) sq_res_0x100_num / 256.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x100, %eax            # imm = 0x100
subl $0x1, %eax
cltd
idivl -0x4(%rbp)
movl %eax, 0x7684(%rip)      # 0x130d4
movslq 0x767d(%rip), %rdi      # 0x130d4
shlq $0x4, %rdi
callq 0x1300
movq %rax, 0x7671(%rip)      # 0x130d8
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x765d(%rip), %eax      # 0x130d4
jge 0xba9f
movq 0x7658(%rip), %rdi      # 0x130d8
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3560
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xba6e
movl $0x0, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jge 0xbaf2
movl -0x8(%rbp), %eax
imull -0x8(%rbp), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movq 0x7610(%rip), %rdi      # 0x130d8
movl -0xc(%rbp), %eax
cltd
idivl -0x4(%rbp)
cltq
shlq $0x4, %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
cltd
idivl -0x4(%rbp)
movslq %edx, %rsi
callq 0x7460
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xbaa6
movl $0x0, 0x75e4(%rip)      # 0x130e0
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x75c8(%rip), %eax      # 0x130d4
jge 0xbb43
movq 0x75c3(%rip), %rdi      # 0x130d8
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x9e60
movq %rax, %rcx
movslq 0x75b1(%rip), %rax      # 0x130e0
addq %rcx, %rax
movl %eax, 0x75a8(%rip)      # 0x130e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xbb03
cvtsi2sdl 0x7595(%rip), %xmm0 # 0x130e0
movsd 0x24d5(%rip), %xmm1     # 0xe028
divsd %xmm1, %xmm0
movsd %xmm0, 0x7589(%rip)     # 0x130e8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/gen-psqr.c
// Function: main
int
main (int argc, char *argv[])
{
  int  limb_bits, nail_bits;

  if (argc != 3)
    {
      fprintf (stderr, "Usage: gen-psqr <limbbits> <nailbits>\n");
      exit (1);
    }

  limb_bits = atoi (argv[1]);
  nail_bits = atoi (argv[2]);

  if (limb_bits <= 0
      || nail_bits < 0
      || nail_bits >= limb_bits)
    {
      fprintf (stderr, "Invalid limb/nail bits: %d %d\n",
               limb_bits, nail_bits);
      exit (1);
    }

  generate_sq_res_0x100 (limb_bits);
  generate_mod (limb_bits, nail_bits);

  print (limb_bits, nail_bits);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0xcafe
movq 0x6515(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x25f3(%rip), %rsi      # 0xf0e0
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0xcb32
cmpl $0x0, -0x18(%rbp)
jl 0xcb32
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0xcb5a
movq 0x64bf(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x25be(%rip), %rsi      # 0xf107
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1100
movl -0x14(%rbp), %edi
callq 0xba30
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0xbb70
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0xc440
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: dlcgold[P]sparsematrix-unimib/main.cpp
// Function: test_vuota(sparse_matrix<int>)
void test_vuota(const smatrixi vuota){
  std::cout << "\n\ntest stampa matrice vuota\n";
  std::cout << vuota << std::endl;
  std::cout << "\ntest evaluate matrice vuota\n";
  positive pos;
  int count = evaluate(vuota, pos);
  assert(count == 0);
  std::cout << "valori accettabili: " << count << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x9251(%rip), %rdi      # 0xbfd8
leaq 0x54ca(%rip), %rsi      # 0x8258
callq 0x20b0
movq -0x20(%rbp), %rsi
movq 0x923a(%rip), %rdi      # 0xbfd8
callq 0x4aa0
movq %rax, %rdi
movq 0x9213(%rip), %rsi      # 0xbfc0
callq 0x20d0
movq 0x921f(%rip), %rdi      # 0xbfd8
leaq 0x54b5(%rip), %rsi      # 0x8275
callq 0x20b0
movq -0x20(%rbp), %rdi
callq 0x4730
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x2dd9
jmp 0x2df8
leaq 0x54b3(%rip), %rdi      # 0x8293
leaq 0x5264(%rip), %rsi      # 0x804b
movl $0x66, %edx
leaq 0x54ab(%rip), %rcx      # 0x829e
callq 0x2070
movq 0x91d9(%rip), %rdi      # 0xbfd8
leaq 0x54b8(%rip), %rsi      # 0x82be
callq 0x20b0
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x2110
movq %rax, %rdi
leaq 0x5324(%rip), %rsi      # 0x8144
callq 0x20b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dlcgold[P]sparsematrix-unimib/main.cpp
// Function: test_duplicati()
void test_duplicati(){
  std::cout << "\ntest inserimento duplicati\n";
  smatrixi testM(0);
  testM.add(1, 0, 0);
  testM.add(2, 1, 2);
  testM.add(5, 0, 0);
  testM.add(2, 1, 2);

  testM.add(4, 0, 0);
  testM.add(5, 0, 0);
  testM.print();
  assert(testM.get_size() == 2);
  std::cout << "test duplicati superato\n";
  testM.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x8ab9(%rip), %rdi      # 0xbfd8
leaq 0x4e6b(%rip), %rsi      # 0x8391
callq 0x20b0
leaq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
movl %esi, -0x4c(%rbp)
callq 0x5710
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %ecx
movl $0x1, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
movl %ecx, %edx
callq 0x5750
jmp 0x3558
movl $0x2, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x5750
jmp 0x3578
movl $0x5, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x5750
jmp 0x3592
movl $0x2, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x5750
jmp 0x35b2
movl $0x4, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x44(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x5750
jmp 0x35cc
movl $0x5, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x5750
jmp 0x35e6
leaq -0x20(%rbp), %rdi
callq 0x5c30
jmp 0x35f1
leaq -0x20(%rbp), %rdi
callq 0x5cd0
movl %eax, -0x5c(%rbp)
jmp 0x35ff
movl -0x5c(%rbp), %eax
cmpl $0x2, %eax
jne 0x3609
jmp 0x363f
leaq 0x4d9e(%rip), %rdi      # 0x83ae
leaq 0x4a34(%rip), %rsi      # 0x804b
movl $0x93, %edx
leaq 0x4da1(%rip), %rcx      # 0x83c4
callq 0x2070
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4700
jmp 0x366e
movq 0x8992(%rip), %rdi      # 0xbfd8
leaq 0x4d8d(%rip), %rsi      # 0x83da
callq 0x20b0
jmp 0x3654
leaq -0x20(%rbp), %rdi
callq 0x5cf0
jmp 0x365f
leaq -0x20(%rbp), %rdi
callq 0x4700
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2120
nopw (%rax,%rax)
// File: dlcgold[P]sparsematrix-unimib/main.cpp
// Function: main
int main(){
  test_fondamentali();
  smatrixi costante(0);
  test_vuota(costante);
  test_point();
  test_duplicati();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
callq 0x2280
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %esi, %esi
callq 0x5710
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x45b0
jmp 0x36b2
leaq -0x48(%rbp), %rdi
callq 0x2d70
jmp 0x36bd
leaq -0x48(%rbp), %rdi
callq 0x4700
callq 0x2e30
jmp 0x36cd
callq 0x3510
jmp 0x36d4
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4700
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x3710
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4700
leaq -0x28(%rbp), %rdi
callq 0x4700
movq -0x50(%rbp), %rdi
callq 0x2120
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dlcgold[P]sparsematrix-unimib/./sparsematrix.h
// Function: void printdef<float>(sparse_matrix<float>, int, int)
void printdef(sparse_matrix<T> smatrix, int n, int m){
  if(n < 0 || m < 0)
    throw NegativeIndexSparseMatrixException();
  for(int i = 0; i < n; i++){
    for(int j = 0; j < m; j++){
      std::cout << smatrix(i, j) << " ";
    }
    std::cout << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x3cf2
cmpl $0x0, -0x10(%rbp)
jge 0x3d2f
movl $0x8, %edi
callq 0x2050
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x2060
movq -0x28(%rbp), %rdi
callq 0x5f00
movq -0x28(%rbp), %rdi
leaq 0x7f45(%rip), %rsi      # 0xbc68
leaq 0x2216(%rip), %rdx      # 0x5f40
callq 0x2100
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3da4
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3d86
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x6230
movss (%rax), %xmm0
movq 0x8271(%rip), %rdi      # 0xbfd8
callq 0x2080
movq %rax, %rdi
leaq 0x45ea(%rip), %rsi      # 0x8360
callq 0x20b0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3d45
movq 0x824b(%rip), %rdi      # 0xbfd8
movq 0x822c(%rip), %rsi      # 0xbfc0
callq 0x20d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d36
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dlcgold[P]sparsematrix-unimib/./sparsematrix.h
// Function: sparse_matrix<float>::sparse_matrix(sparse_matrix<float> const&)
sparse_matrix(const sparse_matrix &other): default_value(other.default_value),
					     dim(other.dim),
					     size_row(other.size_row),
					     size_column(other.size_column),
					     head(nullptr), size(0) {
    node *curr = other.head;

    // eseguo una copia nodo per nodo
    try {
      while(curr != nullptr) {
	add(curr->ret->v, curr->ret->x, curr->ret->y);
	curr = curr->next;
      }		
    }
    catch(...) {
      clear();
      throw NoSparseMatrixException();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movb 0x4(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3e93
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rsi), %edx
movl 0x8(%rsi), %ecx
callq 0x37f0
jmp 0x3e30
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3e10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x5df0
jmp 0x3e5d
movl $0x8, %edi
callq 0x2050
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, (%rdi)
callq 0x63b0
movq -0x38(%rbp), %rdi
leaq 0x7ea3(%rip), %rsi      # 0xbd28
leaq 0x2564(%rip), %rdx      # 0x63f0
callq 0x2100
jmp 0x3ec1
jmp 0x3eaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20f0
jmp 0x3ea8
jmp 0x3eb0
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2120
movq %rax, %rdi
callq 0x5e20
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dlcgold[P]sparsematrix-unimib/./sparsematrix.h
// Function: std::ostream& operator<<<int>(std::ostream&, sparse_matrix<int> const&)
std::ostream &operator<<(std::ostream &os, 
			 const sparse_matrix<T> &smatrix) {
	
  typename sparse_matrix<T>::const_iterator i, ie;
	
  i = smatrix.begin();
  ie = smatrix.end();
  // evito overflow se provo a stampare su una matrice nulla
  if(smatrix.get_size() == 0)
    return os;
  // mi salvo il numero di riga per andare a capo
  int prevrow = i->x;
  
  while(i!=ie) {
    if(i->x != prevrow)
      std::cout << std::endl;
    os << i->v << "\t";
    prevrow = i->x;
    ++i;
  }
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x68d0
leaq -0x28(%rbp), %rdi
callq 0x68d0
jmp 0x4ac7
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x68f0
jmp 0x4ad6
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x60(%rbp)
callq 0x6920
movq -0x60(%rbp), %rdi
callq 0x6940
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x6950
jmp 0x4aff
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0x70(%rbp)
callq 0x6920
movq -0x70(%rbp), %rdi
callq 0x6940
movq -0x18(%rbp), %rdi
callq 0x5cd0
movl %eax, -0x64(%rbp)
jmp 0x4b27
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
jne 0x4b6e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x4c34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x4c53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6940
jmp 0x4c53
leaq -0x20(%rbp), %rdi
callq 0x69b0
movl 0x4(%rax), %eax
movl %eax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6980
testb $0x1, %al
jne 0x4b93
jmp 0x4c25
leaq -0x20(%rbp), %rdi
callq 0x69b0
movl 0x4(%rax), %eax
cmpl -0x50(%rbp), %eax
je 0x4bbb
movq 0x742d(%rip), %rdi      # 0xbfd8
movq 0x740e(%rip), %rsi      # 0xbfc0
callq 0x20d0
jmp 0x4bb9
jmp 0x4bbb
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x69b0
movq -0x80(%rbp), %rdi
movl (%rax), %esi
callq 0x2110
movq %rax, -0x78(%rbp)
jmp 0x4bdd
movq -0x78(%rbp), %rdi
leaq 0x386e(%rip), %rsi      # 0x8456
callq 0x20b0
jmp 0x4bef
leaq -0x20(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x69b0
movq -0x88(%rbp), %rsi
movl 0x4(%rax), %eax
movl %eax, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x69d0
jmp 0x4c17
leaq -0x58(%rbp), %rdi
callq 0x6940
jmp 0x4b7d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6940
leaq -0x20(%rbp), %rdi
callq 0x6940
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x6940
movq -0x30(%rbp), %rdi
callq 0x2120
nopw %cs:(%rax,%rax)
nop
// File: dlcgold[P]sparsematrix-unimib/./sparsematrix.h
// Function: sparse_matrix<int>::print() const
void print() const{
    node *current = head;
    while(current != nullptr){
      std::cout << current->ret->v << " in (" << current->ret->x << ", "
		<< current->ret->y <<")\n";
      current = current->next;
      
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5cc5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
movq 0x6378(%rip), %rdi      # 0xbfd8
callq 0x2110
movq %rax, %rdi
leaq 0x27e9(%rip), %rsi      # 0x8458
callq 0x20b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %esi
callq 0x2110
movq %rax, %rdi
leaq 0x26ce(%rip), %rsi      # 0x835f
callq 0x20b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %esi
callq 0x2110
movq %rax, %rdi
leaq 0x24fe(%rip), %rsi      # 0x81b1
callq 0x20b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5c48
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dlcgold[P]sparsematrix-unimib/./sparsematrix.h
// Function: sparse_matrix<float>::recursive_clear(sparse_matrix<float>::node*)
void recursive_clear(node *n){
    if(n!=nullptr) {
      recursive_clear(n->next);
      delete n->ret;
      n->ret = nullptr;
      delete n;
      size--;
      n = nullptr;   
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5ec4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x5e30
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5e83
movq -0x20(%rbp), %rdi
callq 0x5ed0
movq -0x20(%rbp), %rdi
callq 0x20a0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5eaf
movq -0x28(%rbp), %rdi
callq 0x5ee0
movq -0x28(%rbp), %rdi
callq 0x20a0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq $0x0, -0x10(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dlcgold[P]sparsematrix-unimib/./sparsematrix.h
// Function: sparse_matrix<float>::node::node(float const&, int, int)
node(const T &v, const int x, const int y): next(nullptr){
      try{
	ret = new element(v, x, y);
      }catch(...){
	throw noNodeException{};
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, (%rax)
movl $0xc, %edi
callq 0x20c0
movq %rax, -0x30(%rbp)
jmp 0x5f95
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x6160
jmp 0x5faa
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x602f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5fdb
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20a0
movq -0x20(%rbp), %rdi
callq 0x2040
movl $0x8, %edi
callq 0x2050
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
movq $0x0, (%rdi)
callq 0x6050
movq -0x40(%rbp), %rdi
leaq 0x5c74(%rip), %rsi      # 0xbc80
leaq 0x7d(%rip), %rdx        # 0x6090
callq 0x2100
jmp 0x6046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20f0
jmp 0x602d
jmp 0x6035
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2120
movq %rax, %rdi
callq 0x5e20
nopw %cs:(%rax,%rax)
// File: dlcgold[P]sparsematrix-unimib/./sparsematrix.h
// Function: sparse_matrix<float>::operator()(int, int)
const T& operator()(int x, int y) {
    if(x < 0 || y < 0)
      throw  NegativeIndexSparseMatrixException();
    if((x < size_row) && (y < size_column)){
      node *current = head;
      T& value = default_value;

      // come per la add avanzo fino alle condizioni di arresto
      while(current->next != nullptr &&
	    ((current->next->ret->x == x && current->next->ret->y <= y)
	     || (current->next->ret->x < x))) {
	
	current = current->next;
      }
      // se mi sono fermato sul nodo corrispondente alle coordinate richieste
      // ne resituisco il valore, altrimenti resituisco il valore di default
      if(current->ret->x == x && current->ret->y == y){
	return current->ret->v;
      }else{
	return value;
      }
    }else{
      throw IndexOutOfBoundsException();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6256
cmpl $0x0, -0x18(%rbp)
jge 0x6293
movl $0x8, %edi
callq 0x2050
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x2060
movq -0x38(%rbp), %rdi
callq 0x5f00
movq -0x38(%rbp), %rdi
leaq 0x59e1(%rip), %rsi      # 0xbc68
leaq -0x34e(%rip), %rdx      # 0x5f40
callq 0x2100
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6368
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x6368
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x39(%rbp)
je 0x631a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x62fd
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %ecx
movb $0x1, %al
cmpl -0x18(%rbp), %ecx
movb %al, -0x3a(%rbp)
jle 0x6314
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6323
jmp 0x6330
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x62c3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x635e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x635e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x63a5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x63a5
movl $0x8, %edi
callq 0x2050
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x2060
movq -0x48(%rbp), %rdi
callq 0x60b0
movq -0x48(%rbp), %rdi
leaq 0x58ff(%rip), %rsi      # 0xbc98
leaq -0x2b0(%rip), %rdx      # 0x60f0
callq 0x2100
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: BlinfoldKing[P]lisval/src/lib/evaluator.cpp
// Function: Evaluator::dec()
pair<Token*, function<Token*(Token*)>> Evaluator::dec() {
    Token* op = new UnaryOperator(UnaryOperatorType::DEC);
    Token* var1 = new Variable("Pattern");
    List* signature = new List();
    signature->list.push_back(op);
    signature->list.push_back(var1);
    Token* token = signature;
    auto res = make_pair(token, [this](Token* input) {
            List* list = static_cast<List*>(input);

            Token* new_signature = this->eval(list->list[1]);

            auto new_rule = make_pair(new_signature, [](Token* input) {
                        Token* res = new Boolean(true);
                        return res;
            });

            this->state.push_back(new_rule);

            Token* res = new Boolean(true);
            return res;
    });

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x8, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movl $0x1, %esi
callq 0x117f0
jmp 0x4732
movq -0x88(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x28, %edi
callq 0x32b0
movq %rax, -0xb0(%rbp)
movb $0x1, -0x52(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x34a0
movq -0xa8(%rbp), %rdx
leaq 0x1ec0f(%rip), %rsi     # 0x2337f
leaq -0x50(%rbp), %rdi
callq 0x33b0
jmp 0x477b
movq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x11830
jmp 0x478d
movb $0x0, -0x52(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31c0
leaq -0x51(%rbp), %rdi
callq 0x3300
movq -0xb0(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x20, %edi
callq 0x32b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
callq 0x11870
jmp 0x47cc
movq -0xb8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x118b0
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x118b0
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x48d0
movq -0xa0(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x4900
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x32c0
jmp 0x48c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4883
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31c0
leaq -0x51(%rbp), %rdi
callq 0x3300
testb $0x1, -0x52(%rbp)
jne 0x4894
jmp 0x48a5
movq -0xb0(%rbp), %rdi
movl $0x28, %esi
callq 0x32c0
jmp 0x48c4
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x32c0
movq -0x20(%rbp), %rdi
callq 0x3490
nopl (%rax)