LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/main.cc
// Function: parseInput(std::vector<Vec3, std::allocator<Vec3>>&, PointCloudSegmenter)
void parseInput(std::vector<Vec3>& in, PointCloudSegmenter seg) {
  std::ifstream infile("../velodyne_points_1/data/0000000001.txt");
  double x, y, z, v;
  int k = 0;

  while (infile >> x >> y >> z >> v)
  {
    Vec3 pt = Vec3(x, y, z);
    if (pt.r > 0) {
      if (pt.x < seg.max_x && pt.x > -seg.max_x && pt.y < seg.max_y && pt.y > -seg.max_y && pt.z > -2) {
        if (pt.theta < 3 && pt.theta > -25) {
          in.push_back(pt);
        }
      }
    }

  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
leaq 0x36ca(%rip), %rsi      # 0x7117
leaq -0x278(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x22b0
leaq -0x40(%rbp), %r13
leaq -0x38(%rbp), %r14
leaq -0x70(%rbp), %r15
leaq -0x64(%rbp), %r12
leaq -0x278(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2100
movq %rax, %rdi
movq %r13, %rsi
callq 0x2100
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %rdi
movq %r15, %rsi
callq 0x2100
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3b64
cvtsd2ss -0x48(%rbp), %xmm0
cvtsd2ss -0x40(%rbp), %xmm1
cvtsd2ss -0x38(%rbp), %xmm2
movq %r12, %rdi
callq 0x43c6
movss -0x58(%rbp), %xmm0
ucomiss 0x35ae(%rip), %xmm0     # 0x7080
jbe 0x3a6c
movl 0x80(%rbx), %eax
cvtsi2ss %eax, %xmm1
movss -0x64(%rbp), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x3a6c
negl %eax
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x3a6c
movl 0x84(%rbx), %eax
cvtsi2ss %eax, %xmm1
movss -0x60(%rbp), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x3a6c
negl %eax
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x3a6c
movss -0x5c(%rbp), %xmm0
ucomiss 0x356a(%rip), %xmm0     # 0x7094
jbe 0x3a6c
movss -0x54(%rbp), %xmm0
movss 0x355b(%rip), %xmm1     # 0x7098
ucomiss %xmm0, %xmm1
jbe 0x3a6c
ucomiss 0x354f(%rip), %xmm0     # 0x709c
jbe 0x3a6c
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x3ca0
jmp 0x3a6c
leaq -0x278(%rbp), %rdi
callq 0x2030
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b84
movq %rax, %rbx
leaq -0x278(%rbp), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/main.cc
// Function: generateOutput(std::vector<Vec3, std::allocator<Vec3>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void generateOutput(std::vector<Vec3>& pts, std::string file_name) {
  std::ofstream file;
  file.open (file_name);
  std::vector<Vec3>::iterator it;
  for (it = pts.begin(); it != pts.end(); it++) {
    file << it->x << " " << it->y << " " << it->z << " " << it->label << "\n";
  }
  file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x228(%rbp), %r15
movq %r15, %rdi
callq 0x2270
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x20a0
movq (%rbx), %r13
leaq -0x228(%rbp), %r14
leaq 0x350e(%rip), %r15      # 0x70f1
leaq 0x35fe(%rip), %r12      # 0x71e8
cmpq 0x8(%rbx), %r13
je 0x3c5a
movss (%r13), %xmm0
movq %r14, %rdi
callq 0x2150
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movss 0x4(%r13), %xmm0
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movss 0x8(%r13), %xmm0
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movss 0x18(%r13), %xmm0
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
addq $0x1c, %r13
jmp 0x3bea
leaq -0x228(%rbp), %rdi
callq 0x21f0
leaq -0x228(%rbp), %rdi
callq 0x2210
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c88
jmp 0x3c88
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./point_cloud_segmenter.h
// Function: ScanlinePointCloud::ScanlinePointCloud(std::vector<Vec3, std::allocator<Vec3>>&)
ScanlinePointCloud(std::vector<Vec3> & pts) : scanline_points(pts) {
    // Filter out ground labels
    for (int i = 0; i < pts.size(); i++) {
      Vec3 point = pts[i];
      if (point.label != -3) {
        ScanlinePoint wrapper(point, i);
        filtered_points.push_back(wrapper);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
xorl %r12d, %r12d
pushq $0x1c
popq %r13
xorl %r15d, %r15d
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %r15, %rax
jbe 0x3f85
movq 0x10(%rcx,%r12), %rax
movq %rax, -0x30(%rbp)
movups (%rcx,%r12), %xmm0
movaps %xmm0, -0x40(%rbp)
movss 0x18(%rcx,%r12), %xmm0
ucomiss 0x3135(%rip), %xmm0     # 0x7088
jne 0x3f57
jnp 0x3f7c
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movaps -0x40(%rbp), %xmm1
movaps %xmm1, -0x70(%rbp)
movss %xmm0, -0x58(%rbp)
movq %r15, -0x50(%rbp)
movq %rbx, %rdi
leaq -0x70(%rbp), %rsi
callq 0x4448
incq %r15
addq $0x1c, %r12
jmp 0x3f1f
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x464c
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::KDTreeSingleIndexAdaptor(int, ScanlinePointCloud const&, nanoflann::KDTreeSingleIndexAdaptorParams const&)
KDTreeSingleIndexAdaptor(const int dimensionality, const DatasetAdaptor& inputData, const KDTreeSingleIndexAdaptorParams& params = KDTreeSingleIndexAdaptorParams() ) :
			dataset(inputData), index_params(params), root_node(NULL), distance(inputData)
		{
			m_size = dataset.kdtree_get_point_count();
			m_size_at_index_build = m_size;
			dim = dimensionality;
			if (DIM>0) dim=DIM;
			m_leaf_max_size = params.leaf_max_size;

			// Create a permutable array of indices to the input vectors.
			init_vind();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq (%rcx), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x68(%rdi), %r14
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x80(%rdi)
movq %rdx, 0x90(%rdi)
movq 0x10(%rdx), %rax
subq 0x8(%rdx), %rax
pushq $0x28
popq %rsi
cqto
idivq %rsi
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movl $0x3, 0x40(%rdi)
movq (%rcx), %rax
movq %rax, 0x18(%rdi)
callq 0x5e9e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x4694
movq %rbx, %rdi
callq 0x46dc
movq %r15, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::buildIndex()
void buildIndex()
		{
			init_vind();
			freeIndex();
			m_size_at_index_build = m_size;
			if(m_size == 0) return;
			computeBoundingBox(root_bbox);
			root_node = divideTree(0, m_size, root_bbox );   // construct the tree
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5e9e
movq %rbx, %rdi
callq 0x6110
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x4080
leaq 0x50(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6134
movq 0x30(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x625c
movq %rax, 0x48(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: bool nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::findNeighbors<nanoflann::KNNResultSet<float, unsigned long, unsigned long>>(nanoflann::KNNResultSet<float, unsigned long, unsigned long>&, float const*, nanoflann::SearchParams const&) const
bool findNeighbors(RESULTSET& result, const ElementType* vec, const SearchParams& searchParams) const
		{
			assert(vec);
            if (size() == 0)
                return false;
			if (!root_node)
                throw std::runtime_error("[nanoflann] findNeighbors() called before building the index.");
			float epsError = 1+searchParams.eps;

			distance_vector_t dists; // fixed or variable-sized container (depending on DIM)
			dists.assign((DIM>0 ? DIM : dim) ,0); // Fill it with zeros.
			DistanceType distsq = computeInitialDistances(vec, dists);
			searchLevel(result, vec, root_node, distsq, dists, epsError);  // "count_leaf" parameter removed since was neither used nor returned to the user.
            return result.full();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdx, %rdx
je 0x41df
movq %rdi, %r15
cmpq $0x0, 0x30(%rdi)
je 0x41d0
cmpq $0x0, 0x48(%r15)
je 0x41fe
movq %rdx, %r14
movq %rsi, %rbx
movss 0x4(%rcx), %xmm0
xorl %eax, %eax
cmpq $0x3, %rax
je 0x418a
andl $0x0, -0x30(%rbp,%rax,4)
incq %rax
jmp 0x417a
addss 0x2efe(%rip), %xmm0     # 0x7090
movss %xmm0, -0x24(%rbp)
leaq -0x30(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x697e
movq 0x48(%r15), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %r8
movss -0x24(%rbp), %xmm1
callq 0x69fa
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
sete %al
jmp 0x41d2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x304e(%rip), %rdi      # 0x7234
leaq 0x304b(%rip), %rsi      # 0x7238
leaq 0x3054(%rip), %rcx      # 0x7248
movl $0x387, %edx            # imm = 0x387
callq 0x20f0
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x31b8(%rip), %rsi      # 0x73c8
movq %rax, %rdi
callq 0x2060
movq 0x6dd1(%rip), %rsi      # 0xaff0
movq 0x6d9a(%rip), %rdx      # 0xafc0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./vec3.h
// Function: Vec3::Vec3(float, float, float)
Vec3(float a, float b, float c) : x(a), y(b), z(c) {
      r = sqrt(x*x + y*y);
      theta = atan2(z, r) * 180 / 3.1415926;
      label = -1;
      theta_horizontal = atan2(y, x) - 3.14159265/2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss %xmm0, (%rdi)
movss %xmm1, 0x4(%rdi)
movss %xmm2, 0x8(%rdi)
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
sqrtss %xmm0, %xmm1
movss %xmm1, 0xc(%rdi)
movaps %xmm2, %xmm0
callq 0x21e0
mulss 0x2c9e(%rip), %xmm0     # 0x70a0
cvtss2sd %xmm0, %xmm0
divsd 0x2c12(%rip), %xmm0     # 0x7020
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rbx)
movl $0xbf800000, 0x18(%rbx) # imm = 0xBF800000
movss (%rbx), %xmm1
movss 0x4(%rbx), %xmm0
callq 0x21e0
cvtss2sd %xmm0, %xmm0
addsd 0x2bf0(%rip), %xmm0     # 0x7028
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::PooledAllocator::free_all()
void free_all()
		{
			while (base != NULL) {
				void *prev = *(static_cast<void**>( base)); /* Get pointer to prev block. */
				::free(base);
				base = prev;
			}
			internal_init();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x46cc
movq (%rdi), %r14
callq 0x21c0
movq %r14, 0x8(%rbx)
movq %r14, %rdi
jmp 0x46b6
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::init_vind()
void init_vind()
		{
			// Create a permutable array of indices to the input vectors.
			m_size = dataset.kdtree_get_point_count();
			if (vind.size()!=m_size) vind.resize(m_size);
			for (size_t i = 0; i < m_size; i++) vind[i] = i;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movq 0x10(%rcx), %rax
subq 0x8(%rcx), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movq %rax, 0x30(%rdi)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
je 0x5ee0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5ef8
movq (%rbx), %rcx
xorl %eax, %eax
cmpq 0x30(%rbx), %rax
jae 0x5ef1
movq %rax, (%rcx,%rax,8)
incq %rax
jmp 0x5ee2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::computeBoundingBox(nanoflann::CArray<nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::Interval, 3ul>&)
void computeBoundingBox(BoundingBox& bbox)
		{
			bbox.resize((DIM>0 ? DIM : dim));
			if (dataset.kdtree_get_bbox(bbox))
			{
				// Done! It was implemented in derived class
			}
			else
			{
				const size_t N = dataset.kdtree_get_point_count();
				if (!N) throw std::runtime_error("[nanoflann] computeBoundingBox() called but no data points found.");
				for (int i=0; i<(DIM>0 ? DIM : dim); ++i) {
					bbox[i].low =
					bbox[i].high = dataset_get(0,i);
				}
				for (size_t k=1; k<N; ++k) {
					for (int i=0; i<(DIM>0 ? DIM : dim); ++i) {
						if (dataset_get(k,i)<bbox[i].low) bbox[i].low = dataset_get(k,i);
						if (dataset_get(k,i)>bbox[i].high) bbox[i].high = dataset_get(k,i);
					}
				}
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rsi
movq %rcx, %rax
subq %rsi, %rax
pushq $0x28
popq %rdi
cqto
idivq %rdi
cmpq %rsi, %rcx
je 0x6219
movq %rax, %r15
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x6196
movq %r14, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x64ae
movss %xmm0, 0x4(%rbx,%r12,8)
movss %xmm0, (%rbx,%r12,8)
incq %r12
jmp 0x6171
pushq $0x1
popq %r12
cmpq %r15, %r12
jae 0x620a
xorl %r13d, %r13d
cmpq $0x3, %r13
je 0x6205
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x64ae
movss (%rbx,%r13,8), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x61d5
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x64ae
movss %xmm0, (%rbx,%r13,8)
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x64ae
ucomiss 0x4(%rbx,%r13,8), %xmm0
jbe 0x6200
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x64ae
movss %xmm0, 0x4(%rbx,%r13,8)
incq %r13
jmp 0x61a2
incq %r12
jmp 0x619a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0xf61(%rip), %rsi       # 0x718c
movq %rax, %rdi
callq 0x2060
movq 0x4db6(%rip), %rsi      # 0xaff0
movq 0x4d7f(%rip), %rdx      # 0xafc0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::PooledAllocator::malloc(unsigned long)
void* malloc(const size_t req_size)
		{
			/* Round size up to a multiple of wordsize.  The following expression
			    only works for WORDSIZE that is a power of 2, by masking last bits of
			    incremented size to zero.
			 */
			const size_t size = (req_size + (WORDSIZE - 1)) & ~(WORDSIZE - 1);

			/* Check whether a new block must be allocated.  Note that the first word
			    of a block is reserved for a pointer to the previous block.
			 */
			if (size > remaining) {

				wastedMemory += remaining;

				/* Allocate new storage. */
				const size_t blocksize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ?
							size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE;

				// use the standard C malloc to allocate memory
				void* m = ::malloc(blocksize);
				if (!m) {
					fprintf(stderr,"Failed to allocate memory.\n");
					return NULL;
				}

				/* Fill first word of new block with pointer to previous block. */
				static_cast<void**>(m)[0] = base;
				base = m;

				size_t shift = 0;
				//int size_t = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1);

				remaining = blocksize - sizeof(void*) - shift;
				loc = (static_cast<char*>(m) + sizeof(void*) + shift);
			}
			void* rloc = loc;
			loc = static_cast<char*>(loc) + size;
			remaining -= size;

			usedMemory += size;

			return rloc;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0xf, %rbx
andq $-0x10, %rbx
movq (%rdi), %r15
cmpq %r15, %rbx
jbe 0x66be
addq %r15, 0x20(%r14)
leaq 0x17(%rbx), %rax
cmpq $0x2001, %rax           # imm = 0x2001
movl $0x2000, %r15d          # imm = 0x2000
cmovaeq %rax, %r15
movq %r15, %rdi
callq 0x21d0
testq %rax, %rax
je 0x66df
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%r14)
addq $-0x8, %r15
addq $0x8, %rax
jmp 0x66c2
movq 0x10(%r14), %rax
leaq (%rax,%rbx), %rcx
movq %rcx, 0x10(%r14)
subq %rbx, %r15
movq %r15, (%r14)
addq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x48ea(%rip), %rax      # 0xafd0
movq (%rax), %rcx
leaq 0xade(%rip), %rdi       # 0x71ce
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x22c0
xorl %eax, %eax
jmp 0x66d4
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::computeMinMax(unsigned long*, unsigned long, int, float&, float&)
void computeMinMax(IndexType* ind, IndexType count, int element, ElementType& min_elem, ElementType& max_elem)
		{
			min_elem = dataset_get(ind[0],element);
			max_elem = dataset_get(ind[0],element);
			for (IndexType i=1; i<count; ++i) {
				ElementType val = dataset_get(ind[i],element);
				if (val<min_elem) min_elem = val;
				if (val>max_elem) max_elem = val;
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, %r14
movl %ecx, -0x2c(%rbp)
movq %rdx, -0x40(%rbp)
movq %rsi, %r13
movq %rdi, %r15
movq (%rsi), %rsi
movl %ecx, %edx
callq 0x64ae
movss %xmm0, (%r14)
movq %r13, -0x38(%rbp)
movq (%r13), %rsi
movq %r15, %r12
movq %r15, %rdi
movl -0x2c(%rbp), %edx
movl %edx, %r13d
callq 0x64ae
movss %xmm0, (%rbx)
pushq $0x1
popq %r15
cmpq -0x40(%rbp), %r15
jae 0x678a
movq -0x38(%rbp), %rax
movq (%rax,%r15,8), %rsi
movq %r12, %rdi
movl %r13d, %edx
callq 0x64ae
movss (%r14), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x677c
movss %xmm0, (%r14)
ucomiss (%rbx), %xmm0
jbe 0x6785
movss %xmm0, (%rbx)
incq %r15
jmp 0x6754
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::planeSplit(unsigned long*, unsigned long, int, float&, unsigned long&, unsigned long&)
void planeSplit(IndexType* ind, const IndexType count, int cutfeat, DistanceType &cutval, IndexType& lim1, IndexType& lim2)
		{
			/* Move vector indices for left subtree to front of list. */
			IndexType left = 0;
			IndexType right = count-1;
			for (;; ) {
				while (left<=right && dataset_get(ind[left],cutfeat)<cutval) ++left;
				while (right && left<=right && dataset_get(ind[right],cutfeat)>=cutval) --right;
				if (left>right || !right) break;  // "!right" was added to support unsigned Index types
				std::swap(ind[left], ind[right]);
				++left;
				--right;
			}
			/* If either list is empty, it means that all remaining features
			 * are identical. Split in the middle to maintain a balanced tree.
			 */
			lim1 = left;
			right = count-1;
			for (;; ) {
				while (left<=right && dataset_get(ind[left],cutfeat)<=cutval) ++left;
				while (right && left<=right && dataset_get(ind[right],cutfeat)>cutval) --right;
				if (left>right || !right) break;  // "!right" was added to support unsigned Index types
				std::swap(ind[left], ind[right]);
				++left;
				--right;
			}
			lim2 = left;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
decq %r14
xorl %ebx, %ebx
movq %r14, %r15
cmpq %r15, %rbx
ja 0x67f0
movq (%r12,%rbx,8), %rsi
movq %r13, %rdi
movl -0x2c(%rbp), %edx
callq 0x64ae
movq -0x38(%rbp), %rax
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x67f0
incq %rbx
jmp 0x67c7
decq %r15
testq %r15, %r15
setne %al
cmpq %r15, %rbx
ja 0x681a
testq %r15, %r15
je 0x681a
movq (%r12,%r15,8), %rsi
movq %r13, %rdi
movl -0x2c(%rbp), %edx
callq 0x64ae
movq -0x38(%rbp), %rax
ucomiss (%rax), %xmm0
jae 0x67ed
movb $0x1, %al
cmpq %r15, %rbx
ja 0x683b
testb %al, %al
je 0x683b
movq (%r12,%rbx,8), %rax
movq (%r12,%r15,8), %rcx
movq %rcx, (%r12,%rbx,8)
movq %rax, (%r12,%r15,8)
incq %rbx
decq %r15
jmp 0x67c7
movq -0x40(%rbp), %rax
movq %rbx, (%rax)
cmpq %r14, %rbx
ja 0x686b
movq (%r12,%rbx,8), %rsi
movq %r13, %rdi
movl -0x2c(%rbp), %edx
callq 0x64ae
movq -0x38(%rbp), %rax
movss (%rax), %xmm1
ucomiss %xmm0, %xmm1
jb 0x686b
incq %rbx
jmp 0x6842
decq %r14
testq %r14, %r14
setne %al
cmpq %r14, %rbx
ja 0x6895
testq %r14, %r14
je 0x6895
movq (%r12,%r14,8), %rsi
movq %r13, %rdi
movl -0x2c(%rbp), %edx
callq 0x64ae
movq -0x38(%rbp), %rax
ucomiss (%rax), %xmm0
ja 0x6868
movb $0x1, %al
cmpq %r14, %rbx
ja 0x68b6
testb %al, %al
je 0x68b6
movq (%r12,%rbx,8), %rax
movq (%r12,%r14,8), %rcx
movq %rcx, (%r12,%rbx,8)
movq %rax, (%r12,%r14,8)
incq %rbx
decq %r14
jmp 0x6842
movq 0x10(%rbp), %rax
movq %rbx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, ScanlinePointCloud, float>, ScanlinePointCloud, 3, unsigned long>::computeInitialDistances(float const*, nanoflann::CArray<float, 3ul>&) const
DistanceType computeInitialDistances(const ElementType* vec, distance_vector_t& dists) const
		{
			assert(vec);
			DistanceType distsq = DistanceType();

			for (int i = 0; i < (DIM>0 ? DIM : dim); ++i) {
				if (vec[i] < root_bbox[i].low) {
					dists[i] = distance.accum_dist(vec[i], root_bbox[i].low, i);
					distsq += dists[i];
				}
				if (vec[i] > root_bbox[i].high) {
					dists[i] = distance.accum_dist(vec[i], root_bbox[i].high, i);
					distsq += dists[i];
				}
			}

			return distsq;
		}

// Assembly:
testq %rsi, %rsi
je 0x69d6
xorps %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x3, %rax
je 0x69d5
movss (%rsi,%rax,4), %xmm1
movss 0x50(%rdi,%rax,8), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x69b4
subss %xmm2, %xmm1
mulss %xmm1, %xmm1
movss %xmm1, (%rdx,%rax,4)
addss %xmm1, %xmm0
movss (%rsi,%rax,4), %xmm1
movss 0x54(%rdi,%rax,8), %xmm2
ucomiss %xmm2, %xmm1
jbe 0x69d0
subss %xmm2, %xmm1
mulss %xmm1, %xmm1
movss %xmm1, (%rdx,%rax,4)
addss %xmm1, %xmm0
incq %rax
jmp 0x6988
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x853(%rip), %rdi       # 0x7234
leaq 0x850(%rip), %rsi       # 0x7238
leaq 0xa17(%rip), %rcx       # 0x7406
movl $0x4a1, %edx            # imm = 0x4A1
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./nanoflann.hpp
// Function: nanoflann::KNNResultSet<float, unsigned long, unsigned long>::addPoint(float, unsigned long)
inline void addPoint(DistanceType dist, IndexType index)
		{
			CountType i;
			for (i=count; i>0; --i) {
#ifdef NANOFLANN_FIRST_MATCH   // If defined and two points have the same distance, the one with the lowest-index will be returned first.
				if ( (dists[i-1]>dist) || ((dist==dists[i-1])&&(indices[i-1]>index)) ) {
#else
				if (dists[i-1]>dist) {
#endif
					if (i<capacity) {
						dists[i] = dists[i-1];
						indices[i] = indices[i-1];
					}
				}
				else break;
			}
			if (i<capacity) {
				dists[i] = dist;
				indices[i] = index;
			}
			if (count<capacity) count++;
		}

		inline DistanceType worstDist() const
		{
			return dists[capacity-1];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %r8
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %r8, %rdx
subq $0x1, %r8
jb 0x6bcb
movss (%rcx,%r8,4), %xmm1
ucomiss %xmm0, %xmm1
movq 0x10(%rdi), %r9
jbe 0x6bcf
cmpq %r9, %rdx
jae 0x6b9f
movss %xmm1, (%rcx,%rdx,4)
movq (%rax,%r8,8), %r9
movq %r9, (%rax,%rdx,8)
jmp 0x6b9f
movq 0x10(%rdi), %r9
cmpq %r9, %rdx
jae 0x6be1
movss %xmm0, (%rcx,%rdx,4)
movq %rsi, (%rax,%rdx,8)
movq 0x10(%rdi), %r9
movq 0x18(%rdi), %rax
cmpq %r9, %rax
jae 0x6bf1
incq %rax
movq %rax, 0x18(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mitchellsayer[P]FastPointCloudSegmentation/src/./vec3.h
// Function: Vec3::distance_squared(float const*) const
float distance_squared(const float * v1) const {
      float x_new = this->x - v1[0];
      float y_new = this->y - v1[1];
      float z_new = this->z - v1[2];
      return x_new * x_new + y_new * y_new + z_new * z_new;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm1
subss (%rsi), %xmm1
movss 0x4(%rdi), %xmm2
subss 0x4(%rsi), %xmm2
movss 0x8(%rdi), %xmm0
subss 0x8(%rsi), %xmm0
mulss %xmm2, %xmm2
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/args.cc
// Function: fasttext::Args::Args()
Args::Args() {
  lr = 0.05;
  dim = 100;
  ws = 5;
  epoch = 5;
  minCount = 1;
  minCountLabel = 0;
  neg = 5;
  wordNgrams = 1;
  loss = loss_name::ns;
  model = model_name::sg;
  bucket = 2000000;
  minn = 3;
  maxn = 6;
  thread = 12;
  lrUpdateRate = 100;
  t = 1e-4;
  label = "__label__";
  verbose = 2;
  pretrainedVectors = "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x40(%rdi), %r15
movb %al, 0x50(%rdi)
leaq 0xa8(%rdi), %r12
leaq 0xb8(%rdi), %rcx
movq %rcx, 0xa8(%rdi)
andq $0x0, 0xb0(%rdi)
movb %al, 0xb8(%rdi)
leaq 0xd0(%rdi), %r13
leaq 0xe0(%rdi), %rcx
movq %rcx, 0xd0(%rdi)
andq $0x0, 0xd8(%rdi)
movb %al, 0xe0(%rdi)
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
movq %rax, 0x60(%rdi)
movaps 0xb832(%rip), %xmm0     # 0xf010
movups %xmm0, 0x78(%rdi)
movaps 0xb837(%rip), %xmm0     # 0xf020
movups %xmm0, 0x88(%rdi)
movabsq $0xc00000006, %rax      # imm = 0xC00000006
movq %rax, 0x98(%rdi)
movaps 0xb828(%rip), %xmm0     # 0xf030
movups %xmm0, 0x68(%rdi)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0xa0(%rdi)
leaq 0xb81c(%rip), %rsi      # 0xf040
movq %r12, %rdi
callq 0x3490
movl $0x2, 0xc8(%rbx)
leaq 0xc95f(%rip), %rsi      # 0x1019c
movq %r13, %rdi
callq 0x3490
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movq %r13, %rdi
callq 0x34e8
movq %r12, %rdi
callq 0x34e8
movq %r15, %rdi
callq 0x34e8
movq %r14, %rdi
callq 0x34e8
movq %rbx, %rdi
callq 0x34e8
movq %rbp, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::Dictionary(std::shared_ptr<fasttext::Args>)
Dictionary::Dictionary(std::shared_ptr<Args> args) {
  args_ = args;
  size_ = 0;
  nwords_ = 0;
  nlabels_ = 0;
  ntokens_ = 0;
  word2int_.resize(MAX_VOCAB_SIZE);
  for (int32_t i = 0; i < MAX_VOCAB_SIZE; i++) {
    word2int_[i] = -1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x70(%rdi), %r15
leaq 0x80(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x50(%rdi)
movq %rax, 0x70(%rdi)
andq $0x0, 0x78(%rdi)
movb $0x0, 0x80(%rdi)
callq 0x617e
andq $0x0, 0x58(%rbx)
andl $0x0, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
movl $0x1c9c380, %esi        # imm = 0x1C9C380
movq %r14, %rdi
callq 0x5e72
movq (%r14), %rax
xorl %ecx, %ecx
cmpq $0x1c9c380, %rcx        # imm = 0x1C9C380
je 0x45d3
orl $-0x1, (%rax,%rcx,4)
incq %rcx
jmp 0x45c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x40(%rbx), %r13
leaq 0x28(%rbx), %rbp
movq %r15, %rdi
callq 0x34e8
movq %r13, %rdi
callq 0x6300
movq %rbp, %rdi
callq 0x5ea4
movq %r14, %rdi
callq 0x626a
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x625c
movq %r12, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Dictionary::add(const std::string& w) {
  int32_t h = find(w);
  ntokens_++;

  if (word2int_[h] == -1) {
    entry e;
    e.word = w;
    e.count = 1;

    if( w.find(args_->label) == 0) {
        cur_label_ = w;
        e.type = entry_type::label;
        e.nlabels = 1;
        e.labels.push_back(w);
    }
    else {
        e.type = entry_type::word;
        e.nlabels = 1;
        e.labels.push_back(cur_label_);
    }
    words_.push_back(e);
    word2int_[h] = size_++;
  } else {
    auto e = words_[word2int_[h]];
    if( e.type == entry_type::label ) {
      cur_label_ = e.word;
    }
    else if( std::find( e.labels.begin(), e.labels.end(), cur_label_) == e.labels.end() ) {
        words_[word2int_[h]].labels.push_back(cur_label_);
        ++(words_[word2int_[h]].nlabels);
    }
    words_[word2int_[h]].count++;
  }


}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4622
incq 0x68(%rbx)
movl %eax, %r15d
movq 0x10(%rbx), %rax
movslq (%rax,%r15,4), %rax
cmpq $-0x1, %rax
je 0x4702
imulq $0x68, %rax, %rsi
addq 0x28(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5f48
cmpb $0x1, 0x28(%r14)
jne 0x4765
leaq 0x70(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3140
movq 0x10(%rbx), %rdx
movq 0x28(%rbx), %rcx
jmp 0x47b6
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
andq $0x0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
andq $0x0, 0x50(%rax)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3140
movq $0x1, 0x28(%rsp)
movl $0xa8, %esi
addq (%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x34c0
testq %rax, %rax
je 0x47c5
movb $0x0, 0x30(%rsp)
movb $0x1, 0x50(%rsp)
leaq 0x70(%rbx), %r14
jmp 0x47db
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
leaq 0x70(%rbx), %r14
movq %r14, %rdx
callq 0x6a3d
movq 0x10(%rbx), %rdx
movq 0x28(%rbx), %rcx
cmpq 0x60(%rsp), %rax
jne 0x47b6
movslq (%rdx,%r15,4), %rax
imulq $0x68, %rax, %rax
leaq (%rcx,%rax), %rdi
addq $0x50, %rdi
movq %r14, %rsi
callq 0x5ed0
movq 0x10(%rbx), %rdx
movq 0x28(%rbx), %rcx
movslq (%rdx,%r15,4), %rax
imulq $0x68, %rax, %rax
incb 0x48(%rcx,%rax)
movslq (%rdx,%r15,4), %rax
imulq $0x68, %rax, %rax
incq 0x20(%rcx,%rax)
jmp 0x4807
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x3140
movb $0x1, %al
movb %al, 0x30(%rsp)
movb %al, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x5ed0
leaq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5efc
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
movq 0x10(%rbx), %rcx
movl %eax, (%rcx,%r15,4)
leaq 0x8(%rsp), %rdi
callq 0x5f28
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x481f
jmp 0x481f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5f28
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::getLabels(int)
std::vector<int32_t> Dictionary::getLabels( int32_t i) {
  assert(i >= 0);
  assert(i < nwords_);
  auto labels = words_[i].labels;
  std::vector<int32_t> label_ids;
  for( auto label : labels) {
      int32_t wid = getId(label);
      assert( wid >= nwords_ );  // 
      label_ids.push_back( wid-nwords_);
  }
  std::sort( label_ids.begin(), label_ids.end());
  return label_ids;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testl %edx, %edx
js 0x492d
movq %rsi, %r14
cmpl %edx, 0x5c(%rsi)
jle 0x4946
movq %rdi, %rbx
movl %edx, %eax
movq 0x28(%r14), %rcx
imulq $0x68, %rax, %rax
leaq (%rcx,%rax), %rsi
addq $0x50, %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x5fb4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq (%r12), %r15
movq 0x8(%r12), %rbp
leaq 0x28(%rsp), %r12
leaq 0xc(%rsp), %r13
cmpq %rbp, %r15
je 0x48e8
movq %r12, %rdi
movq %r15, %rsi
callq 0x3340
movq %r14, %rdi
movq %r12, %rsi
callq 0x498e
subl 0x5c(%r14), %eax
jl 0x4910
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6b28
movq %r12, %rdi
callq 0x34e8
addq $0x20, %r15
jmp 0x48aa
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x6c1e
leaq 0x10(%rsp), %rdi
callq 0x6008
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xad73(%rip), %rdi      # 0xf68a
leaq 0xad10(%rip), %rsi      # 0xf62e
leaq 0xad1b(%rip), %rcx      # 0xf640
pushq $0x6c
popq %rdx
callq 0x3160
leaq 0xacf3(%rip), %rdi      # 0xf627
leaq 0xacf3(%rip), %rsi      # 0xf62e
leaq 0xacfe(%rip), %rcx      # 0xf640
pushq $0x66
jmp 0x4927
leaq 0xad31(%rip), %rdi      # 0xf67e
leaq 0xacda(%rip), %rsi      # 0xf62e
leaq 0xace5(%rip), %rcx      # 0xf640
pushq $0x67
jmp 0x4927
jmp 0x4961
movq %rax, %r14
jmp 0x4973
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x34e8
movq %rbx, %rdi
callq 0x626a
leaq 0x10(%rsp), %rdi
callq 0x6008
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::discard(int, float) const
bool Dictionary::discard(int32_t id, real rand) const {
  assert(id >= 0);
  assert(id < nwords_);
  if (args_->model == model_name::sup) return false;
  return rand > pdiscard_[id];
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x4c23
cmpl %esi, 0x5c(%rdi)
jle 0x4c42
movq (%rdi), %rax
cmpl $0x3, 0x8c(%rax)
jne 0x4c14
xorl %eax, %eax
jmp 0x4c21
movl %esi, %eax
movq 0x40(%rdi), %rcx
ucomiss (%rcx,%rax,4), %xmm0
seta %al
popq %rcx
retq
leaq 0xabe2(%rip), %rdi      # 0xf80c
leaq 0xa9fd(%rip), %rsi      # 0xf62e
leaq 0xaaac(%rip), %rcx      # 0xf6e4
movl $0x84, %edx
callq 0x3160
leaq 0xaad3(%rip), %rdi      # 0xf71c
leaq 0xa9de(%rip), %rsi      # 0xf62e
leaq 0xaa8d(%rip), %rcx      # 0xf6e4
movl $0x85, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::initTableDiscard()
void Dictionary::initTableDiscard() {
  pdiscard_.resize(size_);
  for (size_t i = 0; i < size_; i++) {
    real f = real(words_[i].count) / real(ntokens_);
    pdiscard_[i] = sqrt(args_->t / f) + args_->t / f;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x40, %rdi
movslq 0x58(%rbx), %rsi
callq 0x60d4
pushq $0x8
popq %r14
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movslq 0x58(%rbx), %rax
cmpq %rax, %r15
jae 0x53cd
movq 0x28(%rbx), %rax
cvtsi2ssq (%rax,%r14,4), %xmm1
cvtsi2ssq 0x68(%rbx), %xmm0
movq (%rbx), %rax
divss %xmm0, %xmm1
movsd 0xa0(%rax), %xmm0
cvtss2sd %xmm1, %xmm3
divsd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jb 0x538e
sqrtsd %xmm0, %xmm0
jmp 0x53a3
movsd %xmm3, 0x8(%rsp)
callq 0x31d0
movsd 0x8(%rsp), %xmm3
xorpd %xmm2, %xmm2
movq (%rbx), %rax
movsd 0xa0(%rax), %xmm1
divsd %xmm3, %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movq 0x40(%rbx), %rax
movss %xmm0, (%rax,%r15,4)
incq %r15
addq $0x1a, %r14
jmp 0x5352
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::getLine(std::istream&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&) const
int32_t Dictionary::getLine(std::istream& in,
                            std::vector<int32_t>& words,
                            std::vector<int32_t>& labels,
                            std::minstd_rand& rng) const {
  std::uniform_real_distribution<> uniform(0, 1);
  std::string token;
  int32_t ntokens = 0;
  words.clear();
  labels.clear();
  if (in.eof()) {
    in.clear();
    in.seekg(std::streampos(0));
  }
  while (readWord(in, token)) {
    if (token == EOS) break;
    int32_t wid = getId(token);
    if (wid < 0) continue;
    entry_type type = getType(wid);
    ntokens++;
    if (type == entry_type::word && !discard(wid, uniform(rng))) {
      words.push_back(wid);
    }
    if (type == entry_type::label) {
      labels.push_back(wid - nwords_);
    }
    if (words.size() > MAX_LINE_SIZE && args_->model != model_name::sup) break;
  }
  return ntokens;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x18(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorps %xmm0, %xmm0
movhps 0xa0c0(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, 0x20(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x554b
movq %rax, 0x8(%r15)
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x5558
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rsp)
movq (%r12), %rax
movq -0x18(%rax), %rdi
testb $0x2, 0x20(%r12,%rdi)
je 0x5583
addq %r12, %rdi
xorl %esi, %esi
callq 0x3400
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32e0
xorl %ebp, %ebp
leaq 0x38(%rsp), %rbx
movq %r12, %rsi
movq %rbx, %rdx
callq 0x4de6
testb %al, %al
je 0x5653
movq %rbx, %rdi
leaq 0x12cf1(%rip), %rsi     # 0x18298
callq 0x6126
testb %al, %al
jne 0x5653
movq %r13, %rdi
movq %rbx, %rsi
callq 0x498e
movl %eax, 0x8(%rsp)
testl %eax, %eax
js 0x558a
movq %r13, %rdi
movl %eax, %esi
callq 0x4c62
cmpb $0x1, %al
je 0x5612
movzbl %al, %eax
testl %eax, %eax
jne 0x562d
movl 0x8(%rsp), %r14d
leaq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6150
cvtsd2ss %xmm0, %xmm0
movq %r13, %rdi
movl %r14d, %esi
callq 0x4bfa
testb %al, %al
jne 0x562d
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
callq 0x6158
jmp 0x562d
movl 0x8(%rsp), %eax
subl 0x5c(%r13), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x6b28
incl %ebp
movq 0x8(%r15), %rax
subq (%r15), %rax
cmpq $0x1001, %rax           # imm = 0x1001
jb 0x558a
movq (%r13), %rax
cmpl $0x3, 0x8c(%rax)
je 0x558a
leaq 0x38(%rsp), %rdi
callq 0x34e8
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5674
jmp 0x5674
jmp 0x5674
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x34e8
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::save(std::ostream&) const
void Dictionary::save(std::ostream& out) const {
  out.write((char*) &size_, sizeof(int32_t));
  out.write((char*) &nwords_, sizeof(int32_t));
  out.write((char*) &nlabels_, sizeof(int32_t));
  out.write((char*) &ntokens_, sizeof(int64_t));
  for (int32_t i = 0; i < size_; i++) {
    entry e = words_[i];
    out.write(e.word.data(), e.word.size() * sizeof(char));
    out.put(0);
    out.write((char*) &(e.count), sizeof(int64_t));
    out.write((char*) &(e.type), sizeof(entry_type));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rdi), %r15
pushq $0x4
popq %r12
movq %rsi, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3320
leaq 0x5c(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3320
leaq 0x60(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3320
leaq 0x68(%r14), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3320
xorl %ebp, %ebp
movq %rsp, %r12
xorl %r13d, %r13d
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x57b6
movq 0x28(%r14), %rsi
addq %rbp, %rsi
movq %r12, %rdi
callq 0x5f48
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3320
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3040
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x3320
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x3320
movq %r12, %rdi
callq 0x5f28
incq %r13
addq $0x68, %rbp
jmp 0x5753
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5f28
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::load(std::istream&)
void Dictionary::load(std::istream& in) {
  words_.clear();
  for (int32_t i = 0; i < MAX_VOCAB_SIZE; i++) {
    word2int_[i] = -1;
  }
  in.read((char*) &size_, sizeof(int32_t));
  in.read((char*) &nwords_, sizeof(int32_t));
  in.read((char*) &nlabels_, sizeof(int32_t));
  in.read((char*) &ntokens_, sizeof(int64_t));
  for (int32_t i = 0; i < size_; i++) {
    char c;
    entry e;
    while ((c = in.get()) != 0) {
      e.word.push_back(c);
    }
    in.read((char*) &e.count, sizeof(int64_t));
    in.read((char*) &e.type, sizeof(entry_type));
    words_.push_back(e);
    word2int_[find(e.word)] = i;
  }
  initTableDiscard();
  initNgrams();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rdi
movq %rdi, 0x8(%rsp)
callq 0x6176
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x1c9c380, %rcx        # imm = 0x1C9C380
je 0x5812
orl $-0x1, (%rax,%rcx,4)
incq %rcx
jmp 0x5800
leaq 0x58(%rbx), %r12
pushq $0x4
popq %r13
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x32d0
leaq 0x5c(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x32d0
leaq 0x60(%rbx), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x32d0
leaq 0x68(%rbx), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x32d0
leaq 0x20(%rsp), %rbp
xorl %r15d, %r15d
leaq 0x10(%rsp), %r13
cmpl (%r12), %r15d
jge 0x58fc
movq %rbp, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbp)
andq $0x0, 0x30(%rbp)
movups %xmm0, 0x40(%rbp)
andq $0x0, 0x50(%rbp)
movq %r14, %rdi
callq 0x3290
testb %al, %al
je 0x58aa
movsbl %al, %esi
movq %r13, %rdi
callq 0x31f0
jmp 0x5891
movq %r14, %rdi
leaq 0x30(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x32d0
movq %r14, %rdi
leaq 0x38(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x32d0
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x5efc
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4622
movq 0x10(%rbx), %rcx
movl %eax, %eax
movl %r15d, (%rcx,%rax,4)
movq %r13, %rdi
callq 0x5f28
incl %r15d
jmp 0x5862
movq %rbx, %rdi
callq 0x532e
movq %rbx, %rdi
callq 0x4d1c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x591d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5f28
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/matrix.cc
// Function: fasttext::Matrix::addRow(fasttext::Vector const&, long, float)
void Matrix::addRow(const Vector& vec, int64_t i, real a) {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.m_ == n_);
  for (int64_t j = 0; j < n_; j++) {
    data_[i * n_ + j] += a * vec.data_[j];
  }
}

// Assembly:
pushq %rax
testq %rdx, %rdx
js 0x7ae4
cmpq %rdx, 0x8(%rdi)
jle 0x7afd
movq (%rsi), %rax
cmpq 0x10(%rdi), %rax
jne 0x7b16
movq 0x8(%rsi), %rcx
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rdi), %rdx
xorl %esi, %esi
testq %rax, %rax
cmovleq %rsi, %rax
cmpq %rsi, %rax
je 0x7ae2
movss (%rcx,%rsi,4), %xmm1
mulss %xmm0, %xmm1
addss (%rdx,%rsi,4), %xmm1
movss %xmm1, (%rdx,%rsi,4)
incq %rsi
jmp 0x7ac5
popq %rax
retq
leaq 0x7b3c(%rip), %rdi      # 0xf627
leaq 0x7dee(%rip), %rsi      # 0xf8e0
leaq 0x7df5(%rip), %rcx      # 0xf8ee
pushq $0x45
jmp 0x7b2d
leaq 0x7e27(%rip), %rdi      # 0xf92b
leaq 0x7dd5(%rip), %rsi      # 0xf8e0
leaq 0x7ddc(%rip), %rcx      # 0xf8ee
pushq $0x46
jmp 0x7b2d
leaq 0x7e15(%rip), %rdi      # 0xf932
leaq 0x7dbc(%rip), %rsi      # 0xf8e0
leaq 0x7dc3(%rip), %rcx      # 0xf8ee
pushq $0x47
popq %rdx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/matrix.cc
// Function: fasttext::Matrix::dotRow(fasttext::Vector const&, long)
real Matrix::dotRow(const Vector& vec, int64_t i) {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.m_ == n_);
  real d = 0.0;
  for (int64_t j = 0; j < n_; j++) {
    d += data_[i * n_ + j] * vec.data_[j];
  }
  return d;
}

// Assembly:
pushq %rax
testq %rdx, %rdx
js 0x7b7e
cmpq %rdx, 0x8(%rdi)
jle 0x7b97
movq (%rsi), %rax
cmpq 0x10(%rdi), %rax
jne 0x7bb0
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rdi), %rdx
movq 0x8(%rsi), %rcx
xorl %esi, %esi
testq %rax, %rax
cmovleq %rsi, %rax
xorps %xmm0, %xmm0
cmpq %rsi, %rax
je 0x7b7c
movss (%rdx,%rsi,4), %xmm1
mulss (%rcx,%rsi,4), %xmm1
addss %xmm1, %xmm0
incq %rsi
jmp 0x7b64
popq %rax
retq
leaq 0x7aa2(%rip), %rdi      # 0xf627
leaq 0x7d54(%rip), %rsi      # 0xf8e0
leaq 0x7dac(%rip), %rcx      # 0xf93f
pushq $0x4e
jmp 0x7bc7
leaq 0x7d8d(%rip), %rdi      # 0xf92b
leaq 0x7d3b(%rip), %rsi      # 0xf8e0
leaq 0x7d93(%rip), %rcx      # 0xf93f
pushq $0x4f
jmp 0x7bc7
leaq 0x7d7b(%rip), %rdi      # 0xf932
leaq 0x7d22(%rip), %rsi      # 0xf8e0
leaq 0x7d7a(%rip), %rcx      # 0xf93f
pushq $0x50
popq %rdx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::Vector(long, std::vector<int, std::allocator<int>> const&)
Vector::Vector(int64_t m, const std::vector<int32_t>& lbs) 
  : m_(m), data_(new real[m])
{
  zero();
  for( auto l : lbs) {
    assert( l < m_);
    data_[l] = 1.0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
leaq (,%rsi,4), %rax
shrq $0x3e, %rsi
xorl %edi, %edi
negq %rsi
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x3030
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x7d38
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq (%r14), %rdx
movq 0x8(%r14), %rsi
cmpq %rcx, %rax
je 0x7d13
movslq (%rax), %rdi
cmpq %rdi, %rdx
jle 0x7d1b
movl $0x3f800000, (%rsi,%rdi,4) # imm = 0x3F800000
addq $0x4, %rax
jmp 0x7cf9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7c54(%rip), %rdi      # 0xf976
leaq 0x7c54(%rip), %rsi      # 0xf97d
leaq 0x7c5b(%rip), %rcx      # 0xf98b
pushq $0x21
popq %rdx
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O2/ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::addRow(fasttext::Matrix const&, long)
void Vector::addRow(const Matrix& A, int64_t i) {
  assert(i >= 0);
  assert(i < A.m_);
  assert(m_ == A.n_);
  for (int64_t j = 0; j < A.n_; j++) {
    data_[j] += A.data_[i * A.n_ + j];
  }
}

// Assembly:
pushq %rax
testq %rdx, %rdx
js 0x7df0
cmpq %rdx, 0x8(%rsi)
jle 0x7e09
movq (%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x7e22
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rsi), %rdx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
testq %rax, %rax
cmovleq %rsi, %rax
cmpq %rsi, %rax
je 0x7dee
movss (%rdx,%rsi,4), %xmm0
addss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rcx,%rsi,4)
incq %rsi
jmp 0x7dd5
popq %rax
retq
leaq 0x7830(%rip), %rdi      # 0xf627
leaq 0x7b7f(%rip), %rsi      # 0xf97d
leaq 0x7bc6(%rip), %rcx      # 0xf9cb
pushq $0x41
jmp 0x7e39
leaq 0x7bf2(%rip), %rdi      # 0xfa02
leaq 0x7b66(%rip), %rsi      # 0xf97d
leaq 0x7bad(%rip), %rcx      # 0xf9cb
pushq $0x42
jmp 0x7e39
leaq 0x7be2(%rip), %rdi      # 0xfa0b
leaq 0x7b4d(%rip), %rsi      # 0xf97d
leaq 0x7b94(%rip), %rcx      # 0xf9cb
pushq $0x43
popq %rdx
callq 0x3160
nop