LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::U01d()
double RNG::U01d() {
	double u;
	u = U01();
	if (anti_) {
		// Don't forget that U01() returns 1 - u in 
		// the antithetic case 
		u += (U01() - 1.0) * fact;
		return (u < 0.0) ? u + 1.0 : u;
	} else {
		u += U01() * fact;
		return (u < 1.0) ? u : (u - 1.0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x7930
movq -0x20(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
testb $0x1, 0x90(%rax)
je 0x7bfe
movq -0x20(%rbp), %rdi
callq 0x7930
movsd 0x2464(%rip), %xmm1     # 0xa010
subsd %xmm1, %xmm0
movsd -0x18(%rbp), %xmm1
movsd 0x2823(%rip), %xmm2     # 0xa3e0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x7be8
movsd 0x2434(%rip), %xmm0     # 0xa010
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x7bf2
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7c5c
movq -0x20(%rbp), %rdi
callq 0x7930
movsd -0x18(%rbp), %xmm1
movsd 0x27cc(%rip), %xmm2     # 0xa3e0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x23e7(%rip), %xmm0     # 0xa010
ucomisd -0x18(%rbp), %xmm0
jbe 0x7c3c
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x7c52
movsd -0x18(%rbp), %xmm0
movsd 0x23c7(%rip), %xmm1     # 0xa010
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::init()
void RNG::init() {
	anti_ = false;
	inc_prec_ = false;

	/* Information on a stream. The arrays {Cg_, Bg_, Ig_} contain the
	 current state of the stream, the starting state of the current
	 SubStream, and the starting state of the stream. This stream
	 generates antithetic variates if anti_ = true. It also generates
	 numbers with extended precision (53 bits if machine follows IEEE
	 754 standard) if inc_prec_ = true. next_seed_ will be the seed of
	 the next declared RngStream. */

	for (int i = 0; i < 6; ++i) {
		Bg_[i] = Cg_[i] = Ig_[i] = next_seed_[i];
	}
	MatVecModM(A1p127, next_seed_, next_seed_, m1);
	MatVecModM(A2p127, &next_seed_[3], &next_seed_[3], m2);
#ifdef MEASURE_MODULE
	for ( unsigned int i = 0; i < Simulator::run(); i++ )
	reset_next_substream ();
#endif // MEASURE_MODULE
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, 0x90(%rax)
movb $0x0, 0x91(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x6, -0xc(%rbp)
jge 0x7d0b
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0x77b2(%rip), %rcx      # 0xf490
movsd (%rcx,%rdx,8), %xmm0
movslq -0xc(%rbp), %rcx
movsd %xmm0, 0x60(%rax,%rcx,8)
movslq -0xc(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movslq -0xc(%rbp), %rcx
movsd %xmm0, 0x30(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7cc9
leaq 0x294e(%rip), %rdi      # 0xa660
leaq 0x7777(%rip), %rdx      # 0xf490
movsd 0x2687(%rip), %xmm0     # 0xa3a8
movq %rdx, %rsi
callq 0x7d60
leaq 0x2980(%rip), %rdi      # 0xa6b0
leaq 0x7759(%rip), %rdx      # 0xf490
addq $0x18, %rdx
movsd 0x267d(%rip), %xmm0     # 0xa3c0
movq %rdx, %rsi
callq 0x7d60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MatVecModM(double const (*) [3], double const*, double*, double)
void MatVecModM(const double A[3][3], const double s[3], double v[3], double m) {
	int i;
	double x[3]; // Necessary if v = s
	for (i = 0; i < 3; ++i) {
		x[i] = MultModM(A[i][0], s[0], 0.0, m);
		x[i] = MultModM(A[i][1], s[1], x[i], m);
		x[i] = MultModM(A[i][2], s[2], x[i], m);
	}
	for (i = 0; i < 3; ++i)
		v[i] = x[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x7e40
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x20(%rbp), %xmm3
xorps %xmm2, %xmm2
callq 0x8e50
movslq -0x24(%rbp), %rax
movsd %xmm0, -0x40(%rbp,%rax,8)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
movslq -0x24(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm2
movsd -0x20(%rbp), %xmm3
callq 0x8e50
movslq -0x24(%rbp), %rax
movsd %xmm0, -0x40(%rbp,%rax,8)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm1
movslq -0x24(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm2
movsd -0x20(%rbp), %xmm3
callq 0x8e50
movslq -0x24(%rbp), %rax
movsd %xmm0, -0x40(%rbp,%rax,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7d80
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x7e6f
movslq -0x24(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7e47
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::set_package_seed(unsigned long const*)
void RNG::set_package_seed(const unsigned long seed[6]) {
	if (CheckSeed(seed))
		abort();
	for (int i = 0; i < 6; ++i)
		next_seed_[i] = seed[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8260
cmpl $0x0, %eax
je 0x7e9f
callq 0x3100
movl $0x0, -0xc(%rbp)
cmpl $0x6, -0xc(%rbp)
jge 0x7ef6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %xmm0
movaps 0x2550(%rip), %xmm1     # 0xa410
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2554(%rip), %xmm1     # 0xa420
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x75aa(%rip), %rax      # 0xf490
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7ea6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::rand_u01()
double RNG::rand_u01() {
	if (inc_prec_)
		return U01d();
	else
		return U01();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x91(%rax)
je 0x808d
movq -0x18(%rbp), %rdi
callq 0x7b70
movsd %xmm0, -0x8(%rbp)
jmp 0x809b
movq -0x18(%rbp), %rdi
callq 0x7930
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::RNG(char const*)
RNG::RNG(const char *s) {
	if (strlen(s) > 99) {
		strncpy(name_, s, 99);
		name_[100] = 0;
	} else
		strcpy(name_, s);

	init();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30c0
cmpq $0x63, %rax
jbe 0x80fd
movq -0x18(%rbp), %rdi
addq $0x92, %rdi
movq -0x10(%rbp), %rsi
movl $0x63, %edx
callq 0x30e0
movq -0x18(%rbp), %rax
movb $0x0, 0xf6(%rax)
jmp 0x8111
movq -0x18(%rbp), %rdi
addq $0x92, %rdi
movq -0x10(%rbp), %rsi
callq 0x31b0
movq -0x18(%rbp), %rdi
callq 0x7ca0
addq $0x20, %rsp
popq %rbp
retq
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::reset_next_substream()
void RNG::reset_next_substream() {
	MatVecModM(A1p76, Bg_, Bg_, m1);
	MatVecModM(A2p76, &Bg_[3], &Bg_[3], m2);
	for (int i = 0; i < 6; ++i)
		Cg_[i] = Bg_[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x18(%rbp)
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x30, %rdx
leaq 0x251a(%rip), %rdi      # 0xa700
movsd 0x21ba(%rip), %xmm0     # 0xa3a8
callq 0x7d60
movq -0x18(%rbp), %rdx
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x18, %rsi
addq $0x30, %rdx
addq $0x18, %rdx
leaq 0x253f(%rip), %rdi      # 0xa750
movsd 0x21a7(%rip), %xmm0     # 0xa3c0
callq 0x7d60
movl $0x0, -0xc(%rbp)
cmpl $0x6, -0xc(%rbp)
jge 0x824d
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsd 0x30(%rax,%rcx,8), %xmm0
movslq -0xc(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8225
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::set_seed(unsigned long const*)
void RNG::set_seed(const unsigned long seed[6]) {
	if (CheckSeed(seed))
		abort();
	for (int i = 0; i < 6; ++i)
		Cg_[i] = Bg_[i] = Ig_[i] = seed[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8260
cmpl $0x0, %eax
je 0x84fb
callq 0x3100
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x8563
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %xmm0
movaps 0x1ef0(%rip), %xmm1     # 0xa410
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1ef4(%rip), %xmm1     # 0xa420
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movslq -0x14(%rbp), %rcx
movsd %xmm0, 0x60(%rax,%rcx,8)
movslq -0x14(%rbp), %rcx
movsd %xmm0, 0x30(%rax,%rcx,8)
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8502
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::advance_state(long, long)
void RNG::advance_state(long e, long c) {
	double B1[3][3], C1[3][3], B2[3][3], C2[3][3];
	if (e > 0) {
		MatTwoPowModM(A1p0, B1, m1, e);
		MatTwoPowModM(A2p0, B2, m2, e);
	} else if (e < 0) {
		MatTwoPowModM(InvA1, B1, m1, -e);
		MatTwoPowModM(InvA2, B2, m2, -e);
	}
	if (c >= 0) {
		MatPowModM(A1p0, C1, m1, c);
		MatPowModM(A2p0, C2, m2, c);
	} else {
		MatPowModM(InvA1, C1, m1, -c);
		MatPowModM(InvA2, C2, m2, -c);
	}
	if (e) {
		MatMatModM(B1, C1, C1, m1);
		MatMatModM(B2, C2, C2, m2);
	}
	MatVecModM(C1, Cg_, Cg_, m1);
	MatVecModM(C2, &Cg_[3], &Cg_[3], m2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
cmpq $0x0, -0x10(%rbp)
jle 0x85d6
leaq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x21f8(%rip), %rdi      # 0xa7a0
movsd 0x1df8(%rip), %xmm0     # 0xa3a8
callq 0x8750
leaq -0x100(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x2229(%rip), %rdi      # 0xa7f0
movsd 0x1df1(%rip), %xmm0     # 0xa3c0
callq 0x8750
jmp 0x8622
cmpq $0x0, -0x10(%rbp)
jge 0x8620
leaq -0x60(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
subq -0x10(%rbp), %rdx
leaq 0x2250(%rip), %rdi      # 0xa840
movsd 0x1db0(%rip), %xmm0     # 0xa3a8
callq 0x8750
leaq -0x100(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
subq -0x10(%rbp), %rdx
leaq 0x227d(%rip), %rdi      # 0xa890
movsd 0x1da5(%rip), %xmm0     # 0xa3c0
callq 0x8750
jmp 0x8622
cmpq $0x0, -0x18(%rbp)
jl 0x8669
leaq -0xb0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x2165(%rip), %rdi      # 0xa7a0
movsd 0x1d65(%rip), %xmm0     # 0xa3a8
callq 0x8810
leaq -0x150(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x2196(%rip), %rdi      # 0xa7f0
movsd 0x1d5e(%rip), %xmm0     # 0xa3c0
callq 0x8810
jmp 0x86af
leaq -0xb0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
subq -0x18(%rbp), %rdx
leaq 0x21c1(%rip), %rdi      # 0xa840
movsd 0x1d21(%rip), %xmm0     # 0xa3a8
callq 0x8810
leaq -0x150(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
subq -0x18(%rbp), %rdx
leaq 0x21ee(%rip), %rdi      # 0xa890
movsd 0x1d16(%rip), %xmm0     # 0xa3c0
callq 0x8810
cmpq $0x0, -0x10(%rbp)
je 0x86f7
leaq -0x60(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
movsd 0x1cd8(%rip), %xmm0     # 0xa3a8
callq 0x8950
leaq -0x100(%rbp), %rdi
leaq -0x150(%rbp), %rsi
leaq -0x150(%rbp), %rdx
movsd 0x1cce(%rip), %xmm0     # 0xa3c0
callq 0x8950
movq -0x158(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
movsd 0x1c9b(%rip), %xmm0     # 0xa3a8
movq %rdx, %rsi
callq 0x7d60
movq -0x158(%rbp), %rdx
leaq -0x150(%rbp), %rdi
movq %rdx, %rsi
addq $0x18, %rsi
addq $0x18, %rdx
movsd 0x1c8a(%rip), %xmm0     # 0xa3c0
callq 0x7d60
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MatTwoPowModM(double const (*) [3], double (*) [3], double, long)
void MatTwoPowModM(const double A[3][3], double B[3][3], double m, long e) {
	int i, j;
	/* initialize: B = A */
	if (A != B) {
		for (i = 0; i < 3; ++i)
			for (j = 0; j < 3; ++j)
				B[i][j] = A[i][j];
	}
	/* Compute B = A^(2^e) mod m */
	for (i = 0; i < e; i++)
		MatMatModM(B, B, B, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x87d7
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x87d5
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x87c8
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8787
jmp 0x87ca
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x877a
jmp 0x87d7
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x8809
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
callq 0x8950
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x87de
addq $0x30, %rsp
popq %rbp
retq
nop
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MatPowModM(double const (*) [3], double (*) [3], double, long)
void MatPowModM(const double A[3][3], double B[3][3], double m, long n) {
	int i, j;
	double W[3][3];
	/* initialize: W = A; B = I */
	for (i = 0; i < 3; ++i)
		for (j = 0; j < 3; ++j) {
			W[i][j] = A[i][j];
			B[i][j] = 0.0;
		}
	for (j = 0; j < 3; ++j)
		B[j][j] = 1.0;
	/* Compute B = A^n mod m using the binary decomposition of n */
	while (n > 0) {
		if (n % 2)
			MatMatModM(W, B, B, m);
		MatMatModM(W, W, W, m);

		n /= 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x88a6
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x8899
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0x24(%rbp), %rcx
leaq -0x70(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x883d
jmp 0x889b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8830
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x88de
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd 0x1742(%rip), %xmm0     # 0xa010
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x88ad
jmp 0x88e0
cmpq $0x0, -0x20(%rbp)
jle 0x893b
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x8911
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
callq 0x8950
leaq -0x70(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movsd -0x18(%rbp), %xmm0
callq 0x8950
movq -0x20(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
jmp 0x88e0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MatMatModM(double const (*) [3], double const (*) [3], double (*) [3], double)
void MatMatModM(const double A[3][3], const double B[3][3], double C[3][3],
		double m) {
	int i, j;
	double V[3], W[3][3];
	for (i = 0; i < 3; ++i) {
		for (j = 0; j < 3; ++j)
			V[j] = B[j][i];
		MatVecModM(A, V, V, m);
		for (j = 0; j < 3; ++j)

			W[j][i] = V[j];
	}
	for (i = 0; i < 3; ++i)
		for (j = 0; j < 3; ++j)
			C[i][j] = W[i][j];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x8a1a
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x89b7
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0x28(%rbp), %rax
movsd %xmm0, -0x40(%rbp,%rax,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8984
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
callq 0x7d60
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x8a0a
movslq -0x28(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
movslq -0x28(%rbp), %rcx
leaq -0x90(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x89d4
jmp 0x8a0c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8973
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x8a7f
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x8a72
movslq -0x24(%rbp), %rcx
leaq -0x90(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8a2e
jmp 0x8a74
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8a21
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: RNG::write_state() const
void RNG::write_state() const {
	printf("The current state of the Rngstream %s:\n", name_);
	printf(" Cg_ = { ");
	for (int i = 0; i < 5; i++) {
		printf("%lu, ", (unsigned long) Cg_[i]);
	}
	printf("%lu }\n\n", (unsigned long) Cg_[5]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
addq $0x92, %rsi
leaq 0x1a56(%rip), %rdi      # 0xa508
movb $0x0, %al
callq 0x3040
leaq 0x1a70(%rip), %rdi      # 0xa530
movb $0x0, %al
callq 0x3040
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0x8b20
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
movsd 0x18f0(%rip), %xmm1     # 0xa3e8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rsi
leaq 0x1a2c(%rip), %rdi      # 0xa53a
movb $0x0, %al
callq 0x3040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8ace
movq -0x18(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd 0x18b7(%rip), %xmm2     # 0xa3e8
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rsi
leaq 0x19ea(%rip), %rdi      # 0xa540
movb $0x0, %al
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sergiosvieira[P]ptd2ns2/rng.cc
// Function: (anonymous namespace)::MultModM(double, double, double, double)
double MultModM(double a, double s, double c, double m) {
	double v;
	long a1;
	v = a * s + c;

	if (v >= two53 || v <= -two53) {
		a1 = static_cast<long> (a / two17);
		a -= a1 * two17;
		v = a1 * s;
		a1 = static_cast<long> (v / m);
		v -= a1 * m;
		v = v * two17 + a * s + c;
	}
	a1 = static_cast<long> (v / m);
	/* in case v < 0)*/
	if ((v -= a1 * m) < 0.0)
		return v += m;
	else
		return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x155f(%rip), %xmm1     # 0xa3f0
ucomisd %xmm1, %xmm0
jae 0x8eaa
movsd 0x1559(%rip), %xmm0     # 0xa3f8
ucomisd -0x30(%rbp), %xmm0
jb 0x8f7b
movsd -0x10(%rbp), %xmm0
movsd 0x1549(%rip), %xmm1     # 0xa400
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x38(%rbp)
cvtsi2sdq -0x38(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x1512(%rip), %xmm2     # 0xa400
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
cvtsi2sdq -0x38(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x38(%rbp)
cvtsi2sdq -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
mulsd -0x18(%rbp), %xmm1
movsd 0x1497(%rip), %xmm2     # 0xa400
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x38(%rbp)
cvtsi2sdq -0x38(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8fe1
movsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd %xmm0, -0x8(%rbp)
jmp 0x8feb
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::ReedSolomon()
ReedSolomon::ReedSolomon(){
    int i=0;
    unsigned int x=1;
    expTable[0]=1;
    for(i=1;i<255;i++){
        x<<=1;
        if(x>0xff) x^=0x11d;
        unsigned char c=x&0xff;
        expTable[i]=c;
        logTable[c]=i;
    }
    for(i=255;i<512;i++){
        expTable[i]=expTable[i-255];
    }
    logTable[expTable[255]]=255;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x1, -0x10(%rsp)
movb $0x1, (%rax)
movl $0x1, -0xc(%rsp)
cmpl $0xff, -0xc(%rsp)
jge 0x2493
movl -0x10(%rsp), %eax
shll %eax
movl %eax, -0x10(%rsp)
cmpl $0xff, -0x10(%rsp)
jbe 0x2455
movl -0x10(%rsp), %eax
xorl $0x11d, %eax            # imm = 0x11D
movl %eax, -0x10(%rsp)
movq -0x20(%rsp), %rax
movl -0x10(%rsp), %ecx
andl $0xff, %ecx
movb %cl, -0x11(%rsp)
movb -0x11(%rsp), %dl
movslq -0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rsp), %ecx
movb %cl, %dl
movzbl -0x11(%rsp), %ecx
movb %dl, 0x200(%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x242a
movl $0xff, -0xc(%rsp)
cmpl $0x200, -0xc(%rsp)      # imm = 0x200
jge 0x24cf
movq -0x20(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0xff, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movslq -0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x249b
movq -0x20(%rsp), %rax
movzbl 0xff(%rax), %ecx
movb $-0x1, 0x200(%rax,%rcx)
retq
nopw %cs:(%rax,%rax)
// File: NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::multiplyPoly(POLY&, POLY&, unsigned char*)
POLY& ReedSolomon::multiplyPoly(POLY& x,POLY& y,unsigned char* tmp){
    int i=0,j=0;
    int n=x.n+y.n-1;

    for(j=0;j<n;j++) tmp[j]=0;
    for(i=0;i<x.n;i++){
        for(j=0;j<y.n;j++){
            tmp[i+j]^=multiply(x.data[i],y.data[j]);
        }
    }
    for(j=0;j<n;j++) x.data[j]=tmp[j];
    x.n+=y.n-1;
    return x;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x38(%rsp)
movl $0x0, -0x24(%rsp)
movl $0x0, -0x28(%rsp)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
addl 0x8(%rcx), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rsp)
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0x2c(%rsp), %eax
jge 0x2562
movq -0x20(%rsp), %rax
movslq -0x28(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x253d
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x264d
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x263b
movq -0x10(%rsp), %rax
movq (%rax), %rax
movslq -0x24(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x25c2
movq -0x18(%rsp), %rax
movq (%rax), %rax
movslq -0x28(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x25ca
xorl %eax, %eax
movl %eax, -0x3c(%rsp)
jmp 0x260e
movq -0x38(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movslq -0x24(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movzbl 0x200(%rax,%rcx), %ecx
movq -0x18(%rsp), %rdx
movq (%rdx), %rdx
movslq -0x28(%rsp), %rsi
movzbl (%rdx,%rsi), %edx
movzbl 0x200(%rax,%rdx), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rsp)
movl -0x3c(%rsp), %esi
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %ecx
addl -0x28(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x2584
jmp 0x263d
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x256a
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0x2c(%rsp), %eax
jge 0x2689
movq -0x20(%rsp), %rax
movslq -0x28(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rsp), %rax
movq (%rax), %rax
movslq -0x28(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x2655
movq -0x18(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rsp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::evaluatePoly(POLY&, unsigned char)
unsigned char ReedSolomon::evaluatePoly(POLY& x,unsigned char y){
    int i=0;
    unsigned char r=x.data[0];
    for(i=1;i<x.n;i++){
        r=multiply(r,y) ^ x.data[i];
    }
    return r;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x19(%rsp)
movl $0x1, -0x18(%rsp)
movl -0x18(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2766
movzbl -0x19(%rsp), %eax
cmpl $0x0, %eax
je 0x270a
movzbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x2712
xorl %eax, %eax
movl %eax, -0x2c(%rsp)
jmp 0x273e
movq -0x28(%rsp), %rax
movzbl -0x19(%rsp), %ecx
movzbl 0x200(%rax,%rcx), %ecx
movzbl -0x11(%rsp), %edx
movzbl 0x200(%rax,%rdx), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movslq -0x18(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, -0x19(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x26e8
movb -0x19(%rsp), %al
retq
nopl (%rax,%rax)
// File: NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::calcGenerator(POLY&)
POLY& ReedSolomon::calcGenerator(POLY& result){
    int i=0;
    int num=result.n-1;

    unsigned char *tmp=(unsigned char *)malloc(num+1);

    result.data[0]=1;
    result.n=1;
    unsigned char c[2]={0x1,0};
    POLY p={c,2};
    for(i=0;i<num;i++){
        c[1]=expTable[i];
        multiplyPoly(result,p,tmp);
    }
    free(tmp);
    return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x2230
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movb $0x1, (%rax)
movq 0x38(%rsp), %rax
movl $0x1, 0x8(%rax)
movw 0x5833(%rip), %ax       # 0x8004
movw %ax, 0x26(%rsp)
leaq 0x26(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x282c
movq 0x8(%rsp), %rdi
movslq 0x34(%rsp), %rax
movb (%rdi,%rax), %al
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rcx
leaq 0x10(%rsp), %rdx
callq 0x24f0
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x27f0
movq 0x28(%rsp), %rdi
callq 0x2210
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
// File: NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::encodeMessage(POLY&, POLY&)
unsigned char* ReedSolomon::encodeMessage(POLY& msgIn,POLY& generator){
    int i=0;
    int j=0;
    unsigned char coef=0;

    for(i=0;i<msgIn.n;i++){
        coef=msgIn.data[i];
        if(coef!=0){
            for(j=0;j<generator.n;j++){
                msgIn.data[i+j] ^= multiply(generator.data[j], coef);
            }
        }
    }
    return msgIn.data+msgIn.n;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movb $0x0, -0x21(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2968
movq -0x10(%rsp), %rax
movq (%rax), %rax
movslq -0x1c(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rsp)
movzbl -0x21(%rsp), %eax
cmpl $0x0, %eax
je 0x2956
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2954
movq -0x18(%rsp), %rax
movq (%rax), %rax
movslq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x28e4
movzbl -0x21(%rsp), %eax
cmpl $0x0, %eax
jne 0x28ec
xorl %eax, %eax
movl %eax, -0x34(%rsp)
jmp 0x2924
movq -0x30(%rsp), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movslq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movzbl 0x200(%rax,%rcx), %ecx
movzbl -0x21(%rsp), %edx
movzbl 0x200(%rax,%rdx), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %esi
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl -0x1c(%rsp), %ecx
addl -0x20(%rsp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x28b2
jmp 0x2956
jmp 0x2958
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x2876
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
retq
nopl (%rax)
// File: NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::calcSyndrome(POLY&, POLY&)
POLY& ReedSolomon::calcSyndrome(POLY& msg, POLY& result){
    int i=0;
    for(i=0;i<result.n;i++){
        result.data[i] = evaluatePoly(msg, expTable[i]);
    }
    return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x29f3
movq (%rsp), %rax
movq 0x18(%rsp), %rsi
movslq 0xc(%rsp), %rcx
movq %rax, %rdi
movzbl (%rax,%rcx), %edx
callq 0x26b0
movb %al, %dl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x29ac
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: epfml[P]sent2vec/src/args.cc
// Function: fasttext::Args::save(std::ostream&)
void Args::save(std::ostream& out) {
  out.write((char*) &(dim), sizeof(int));
  out.write((char*) &(ws), sizeof(int));
  out.write((char*) &(epoch), sizeof(int));
  out.write((char*) &(minCount), sizeof(int));
  out.write((char*) &(neg), sizeof(int));
  out.write((char*) &(wordNgrams), sizeof(int));
  out.write((char*) &(loss), sizeof(loss_name));
  out.write((char*) &(model), sizeof(model_name));
  out.write((char*) &(bucket), sizeof(int));
  if (model == model_name::cbowCWNgrams)
    out.write((char*) &(bucketChar), sizeof(int));
  out.write((char*) &(minn), sizeof(int));
  out.write((char*) &(maxn), sizeof(int));
  out.write((char*) &(lrUpdateRate), sizeof(int));
  out.write((char*) &(t), sizeof(double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x98, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa0, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa8, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb0, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb4, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xbc, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc0, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc4, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x7c0b
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc8, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xcc, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd0, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x90, %rsi
movl $0x4, %edx
callq 0x55b0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd8, %rsi
movl $0x8, %edx
callq 0x55b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]sent2vec/src/args.cc
// Function: fasttext::Args::load(std::istream&)
void Args::load(std::istream& in) {
  in.read((char*) &(dim), sizeof(int));
  in.read((char*) &(ws), sizeof(int));
  in.read((char*) &(epoch), sizeof(int));
  in.read((char*) &(minCount), sizeof(int));
  in.read((char*) &(neg), sizeof(int));
  in.read((char*) &(wordNgrams), sizeof(int));
  in.read((char*) &(loss), sizeof(loss_name));
  in.read((char*) &(model), sizeof(model_name));
  in.read((char*) &(bucket), sizeof(int));
  if (model == model_name::cbowCWNgrams)
    in.read((char*) &(bucketChar), sizeof(int));
  in.read((char*) &(minn), sizeof(int));
  in.read((char*) &(maxn), sizeof(int));
  in.read((char*) &(lrUpdateRate), sizeof(int));
  in.read((char*) &(t), sizeof(double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x98, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa0, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa8, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb0, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xb4, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xbc, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc0, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc4, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x7d9b
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc8, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xcc, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd0, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x90, %rsi
movl $0x4, %edx
callq 0x5540
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd8, %rsi
movl $0x8, %edx
callq 0x5540
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: epfml[P]sent2vec/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 || args_->model == model_name::sent2vec || args_->model == model_name::cbowCWNgrams) return false;
  return rand > pdiscard_[id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x8f54
jmp 0x8f73
leaq 0x39c9d(%rip), %rdi     # 0x42bf8
leaq 0x39a2c(%rip), %rsi     # 0x4298e
movl $0x62, %edx
leaq 0x39a89(%rip), %rcx     # 0x429f7
callq 0x52d0
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x5c(%rcx), %eax
jge 0x8f81
jmp 0x8fa0
leaq 0x39aa7(%rip), %rdi     # 0x42a2f
leaq 0x399ff(%rip), %rsi     # 0x4298e
movl $0x63, %edx
leaq 0x39a5c(%rip), %rcx     # 0x429f7
callq 0x52d0
movq -0x20(%rbp), %rdi
callq 0xea70
cmpl $0x3, 0xc0(%rax)
je 0x8fd6
movq -0x20(%rbp), %rdi
callq 0xea70
cmpl $0x4, 0xc0(%rax)
je 0x8fd6
movq -0x20(%rbp), %rdi
callq 0xea70
cmpl $0x5, 0xc0(%rax)
jne 0x8fdc
movb $0x0, -0x1(%rbp)
jmp 0x9007
movq -0x20(%rbp), %rdi
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
addq $0x40, %rdi
movslq -0x14(%rbp), %rsi
callq 0xea90
movss -0x24(%rbp), %xmm0
ucomiss (%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]sent2vec/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::vector<int32_t> word_hashes;
  int32_t ntokens = getLine(in, words, word_hashes, labels, rng);
  if (args_->model == model_name::sup) {
    addNgrams(words, word_hashes, args_->wordNgrams);
  }
  return ntokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xe7d0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0xac40
movl %eax, -0x58(%rbp)
jmp 0xb016
movq -0x68(%rbp), %rdi
movl -0x58(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0xea70
cmpl $0x3, 0xc0(%rax)
jne 0xb071
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0xea70
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl 0xb4(%rax), %ecx
leaq -0x40(%rbp), %rdx
callq 0xa240
jmp 0xb058
jmp 0xb071
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xe8c0
jmp 0xb08c
movl -0x44(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xe8c0
movl -0x74(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x57a0
nopw %cs:(%rax,%rax)
// File: epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::loadModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool, int)
void FastText::loadModel(const std::string& filename,
                         const bool inference_mode /* = false */,
                         const bool shared_mem_enabled /* = true */,
                         const int timeout_sec /* = -1 */) {
  std::ifstream ifs(filename, std::ifstream::binary);
  if (!ifs.is_open()) {
    std::cerr << "Model file cannot be opened for loading!" << std::endl;
    exit(EXIT_FAILURE);
  }
  if (!checkModel(ifs)) {
    std::cerr << "Model file has wrong file format!" << std::endl;
    exit(EXIT_FAILURE);
  }
  if (inference_mode) {
    if (shared_mem_enabled) {
      loadModelWithSharedMemory(ifs, filename, timeout_sec);
    } else {
      loadModel(ifs, false);
    }
  } else {
    loadModel(ifs, true);
  }
  ifs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x238(%rbp)
movl $0x4, %edx
callq 0x56d0
movq -0x238(%rbp), %rdi
callq 0x56c0
movb %al, -0x22d(%rbp)
jmp 0x29521
movb -0x22d(%rbp), %al
testb $0x1, %al
jne 0x2958b
jmp 0x2952d
movq 0x35abc(%rip), %rdi     # 0x5eff0
leaq 0x1a245(%rip), %rsi     # 0x43780
callq 0x5420
movq %rax, -0x248(%rbp)
jmp 0x29549
movq -0x248(%rbp), %rdi
movq 0x35a39(%rip), %rsi     # 0x5ef90
callq 0x5460
jmp 0x2955e
movl $0x1, %edi
callq 0x54f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x5130
jmp 0x29671
movq -0x240(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x28a80
movb %al, -0x249(%rbp)
jmp 0x295a6
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x295ed
jmp 0x295b2
movq 0x35a37(%rip), %rdi     # 0x5eff0
leaq 0x1a1e9(%rip), %rsi     # 0x437a9
callq 0x5420
movq %rax, -0x258(%rbp)
jmp 0x295ce
movq -0x258(%rbp), %rdi
movq 0x359b4(%rip), %rsi     # 0x5ef90
callq 0x5460
jmp 0x295e3
movl $0x1, %edi
callq 0x54f0
testb $0x1, -0x11(%rbp)
je 0x29632
testb $0x1, -0x12(%rbp)
je 0x29617
movq -0x240(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x18(%rbp), %ecx
leaq -0x220(%rbp), %rsi
callq 0x29680
jmp 0x29615
jmp 0x29630
movq -0x240(%rbp), %rdi
leaq -0x220(%rbp), %rsi
xorl %edx, %edx
callq 0x29ad0
jmp 0x2962e
jmp 0x29630
jmp 0x2964e
movq -0x240(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movl $0x1, %edx
callq 0x29ad0
jmp 0x2964c
jmp 0x2964e
leaq -0x220(%rbp), %rdi
callq 0x50f0
jmp 0x2965c
leaq -0x220(%rbp), %rdi
callq 0x5130
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x57a0
nopl (%rax)
// File: epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::skipgram(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&)
void FastText::skipgram(Model& model, real lr,
                        const std::vector<int32_t>& line) {
  std::uniform_int_distribution<> uniform(1, args_->ws);
  for (int32_t w = 0; w < line.size(); w++) {
    int32_t boundary = uniform(model.rng);
    const std::vector<int32_t>& ngrams = dict_->getNgrams(line[w]);
    for (int32_t c = -boundary; c <= boundary; c++) {
      if (c != 0 && w + c >= 0 && w + c < line.size()) {
        model.update(ngrams, line[w + c], lr);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xea70
movl 0x98(%rax), %edx
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0xf2a0
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf0e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x2afdb
movq -0x10(%rbp), %rsi
addq $0x110, %rsi            # imm = 0x110
leaq -0x28(%rbp), %rdi
callq 0xf2d0
movq -0x48(%rbp), %rdi
movl %eax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x33af0
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xe560
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x85a0
movq %rax, -0x38(%rbp)
xorl %eax, %eax
subl -0x30(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jg 0x2afcb
cmpl $0x0, -0x3c(%rbp)
je 0x2afbe
movl -0x2c(%rbp), %eax
addl -0x3c(%rbp), %eax
cmpl $0x0, %eax
jl 0x2afbe
movl -0x2c(%rbp), %eax
addl -0x3c(%rbp), %eax
cltq
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf0e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2afbe
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %eax
addl -0x3c(%rbp), %eax
movslq %eax, %rsi
callq 0xe560
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl (%rax), %edx
movss -0x14(%rbp), %xmm0
callq 0x22d20
jmp 0x2afc0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2af4e
jmp 0x2afcd
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2aee1
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::printSentenceVectors()
void FastText::printSentenceVectors() {
  if (args_->model == model_name::sup || args_->model == model_name::sent2vec || args_->model == model_name::cbowCWNgrams) {
    textVectors();
  } else {
    sentenceVectors();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xea70
cmpl $0x3, 0xc0(%rax)
je 0x2dbc6
movq -0x10(%rbp), %rdi
callq 0xea70
cmpl $0x4, 0xc0(%rax)
je 0x2dbc6
movq -0x10(%rbp), %rdi
callq 0xea70
cmpl $0x5, 0xc0(%rax)
jne 0x2dbd1
movq -0x10(%rbp), %rdi
callq 0x2cb60
jmp 0x2dbda
movq -0x10(%rbp), %rdi
callq 0x2c6d0
addq $0x10, %rsp
popq %rbp
retq