LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::transpose() const
Matrix<T> transpose(void) const
    {
        Matrix trans(cols_, rows_);
        for (int y = 0; y < rows_; ++y)
            for (int x = 0; x < cols_; ++x)
                trans(x, y) = (*this)(y, x);
        return trans;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
movl 0xc(%rax), %esi
movl 0x8(%rax), %edx
callq 0x3710
movl $0x0, -0x18(%rbp)
movq -0x38(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3360
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3350
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x8860
movq -0x48(%rbp), %rdi
movss %xmm0, -0x54(%rbp)
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x37d0
movq %rax, -0x50(%rbp)
jmp 0x3321
movq -0x50(%rbp), %rax
movss -0x54(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x32ec
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x34d0
jmp 0x337d
jmp 0x3352
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32d9
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3373
movq -0x48(%rbp), %rdi
callq 0x34d0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: operator<<(std::ostream&, Matrix<float>&)
std::ostream& operator<<(std::ostream& os, Matrix& m)
    {
        for (int r = 0; r < m.get_rows(); r++)
        {
            os << m(r, 0);
            for (int c = 1; c < m.get_cols(); c++)
                os << "\t" << m(r, c);
            os << std::endl;
        }
        return os;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x92c0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x34be
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x37d0
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
callq 0x20f0
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x92e0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x34a0
movq -0x8(%rbp), %rdi
leaq 0x6e5f(%rip), %rsi      # 0xa2cf
callq 0x2140
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x37d0
movq -0x38(%rbp), %rdi
movss (%rax), %xmm0
callq 0x20f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x344d
movq -0x8(%rbp), %rdi
movq 0xcafd(%rip), %rsi      # 0xffa8
callq 0x2170
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3407
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::operator=(Matrix<float> const&)
Matrix& operator=(const Matrix<T>& m)
    {
        data_ = m.data_;
        rows_ = m.rows_;
        cols_ = m.cols_;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x53a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: theolepage[P]prophecy/src/layer_implem/dense_layer.hh
// Function: DenseLayer<float>::feedforward(Matrix<float> const&, bool)
Matrix<T> feedforward(const Matrix<T>& input, bool training)
    {
        auto z = Matrix<T>::dot(this->weights_, input);
        z += this->biases_;
        auto a = z.map(this->activation_.f_);

        if (training)
        {
            this->last_a_ = a;
            this->last_z_ = z;
        }

        if (this->next_ == nullptr)
            return a;
        return this->next_->feedforward(a, training);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
addq $0x90, %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x80f0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
addq $0xb0, %rsi
callq 0x8130
jmp 0x7661
movq -0xa8(%rbp), %rsi
addq $0x110, %rsi            # imm = 0x110
leaq -0x90(%rbp), %rdi
callq 0x7ff0
jmp 0x767d
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x8240
jmp 0x7693
leaq -0x90(%rbp), %rdi
callq 0x5070
testb $0x1, -0x19(%rbp)
je 0x76fd
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x70(%rbp), %rsi
callq 0x7220
movq -0xa8(%rbp), %rdi
addq $0x30, %rdi
leaq -0x40(%rbp), %rsi
callq 0x7220
jmp 0x76fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x77ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5070
jmp 0x77ab
movq -0xa8(%rbp), %rdi
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8360
testb $0x1, %al
jne 0x771a
jmp 0x774f
movq -0xb8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3230
jmp 0x772c
movl $0x1, -0x94(%rbp)
jmp 0x7789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x34d0
jmp 0x77ab
movq -0xa8(%rbp), %rdi
subq $-0x80, %rdi
callq 0x7270
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
leaq -0x70(%rbp), %rdx
callq *%rax
jmp 0x777f
movl $0x1, -0x94(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x34d0
leaq -0x40(%rbp), %rdi
callq 0x34d0
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x34d0
movq -0x48(%rbp), %rdi
callq 0x2200
nopl (%rax)
// File: theolepage[P]prophecy/src/layer_implem/dense_layer.hh
// Function: DenseLayer<float>::update(float)
void update(T learning_rate)
    {
        // Update weights_ and biases_
        for (int i = 0; i < this->weights_.get_rows(); i++)
        {
            for (int j = 0; j < this->weights_.get_cols(); j++)
                this->weights_(i, j) -= learning_rate * this->delta_weights_(i, j);
            this->biases_(i, 0) -= learning_rate * this->delta_biases_(i, 0);
        }

        // Reset delta_weights_ and delta_biases_
        this->delta_weights_.fill(fill_type::ZERO);
        this->delta_biases_.fill(fill_type::ZERO);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x90, %rdi
callq 0x92c0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x7ec1
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
addq $0x90, %rdi
callq 0x92e0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0x7e4e
movq -0x20(%rbp), %rdi
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
addq $0xd0, %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x37d0
movq -0x20(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
addq $0x90, %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x37d0
movss -0x30(%rbp), %xmm0
movss -0x2c(%rbp), %xmm2
movss (%rax), %xmm1
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7dba
movq -0x20(%rbp), %rdi
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
addq $0xf0, %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x37d0
movq -0x20(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x34(%rbp)
addq $0xb0, %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x37d0
movss -0x38(%rbp), %xmm0
movss -0x34(%rbp), %xmm2
movss (%rax), %xmm1
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7d90
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movl $0x2, %esi
callq 0x9120
movq -0x20(%rbp), %rdi
addq $0xf0, %rdi
movl $0x2, %esi
callq 0x9120
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::operator+=(Matrix<float> const&)
Matrix<T>& operator+=(const Matrix &right)
    {
        if (cols_ != right.cols_ || rows_ != right.rows_)
            throw std::invalid_argument("+ on Matrix need same width and height");
        for (int i = 0; i < rows_; ++i)
        {
            for (int j = 0; j < cols_; ++j)
                (*this)(i, j) += right(i, j);
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x8164
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x81b4
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1fdf(%rip), %rsi      # 0xa15e
callq 0x2220
jmp 0x8186
movq -0x38(%rbp), %rdi
movq 0x7e4f(%rip), %rsi      # 0xffe0
movq 0x7e38(%rip), %rdx      # 0xffd0
callq 0x21f0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20e0
jmp 0x822c
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x8222
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x8215
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x8860
movq -0x30(%rbp), %rdi
movss %xmm0, -0x3c(%rbp)
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x37d0
movss -0x3c(%rbp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x81ce
jmp 0x8217
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x81bb
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
nop
// File: theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::map(std::function<float (float)>) const
Matrix<T> map(std::function<T(T)> value_initializer) const
    {
        assert(data_ != nullptr);
        Matrix<T> result(rows_, cols_);
        for (int i = 0; i < rows_ * cols_; ++i)
            result.data_[i] = value_initializer(data_[i]);
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x88e0
testb $0x1, %al
jne 0x827e
jmp 0x8280
jmp 0x829f
leaq 0x1efe(%rip), %rdi      # 0xa185
leaq 0x1e0a(%rip), %rsi      # 0xa098
movl $0x6a, %edx
leaq 0x1efc(%rip), %rcx      # 0xa196
callq 0x20d0
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movb $0x0, -0x19(%rbp)
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x3710
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdx
movl -0x20(%rbp), %eax
movl 0x8(%rdx), %ecx
imull 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x8330
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movslq -0x20(%rbp), %rsi
callq 0x4490
movq -0x50(%rbp), %rdi
movss (%rax), %xmm0
callq 0x5f00
movss %xmm0, -0x54(%rbp)
jmp 0x82f4
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movslq -0x20(%rbp), %rsi
callq 0x4490
movss -0x54(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x82bd
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x34d0
jmp 0x834d
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8343
movq -0x48(%rbp), %rdi
callq 0x34d0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::map_inplace(std::function<float (float)>)
Matrix<T>& map_inplace(std::function<T(T)> value_initializer)
    {
        assert(data_ != nullptr);
        for (int i = 0; i < rows_ * cols_; ++i)
            data_[i] = value_initializer(data_[i]);
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x88e0
testb $0x1, %al
jne 0x8a3f
jmp 0x8a41
jmp 0x8a60
leaq 0x173d(%rip), %rdi      # 0xa185
leaq 0x1649(%rip), %rsi      # 0xa098
movl $0x62, %edx
leaq 0x1780(%rip), %rcx      # 0xa1db
callq 0x20d0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %eax
movl 0x8(%rdx), %ecx
imull 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x8ac1
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4490
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
callq 0x5f00
movq -0x20(%rbp), %rdi
movss %xmm0, -0x2c(%rbp)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4490
movss -0x2c(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8a67
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::multiply_inplace(Matrix<float> const&)
Matrix<T>& multiply_inplace(const Matrix& b)
    {
        if (rows_ != b.rows_ || cols_ != b.cols_)
            throw "Invalid matrix shape";

        for (int i = 0; i < rows_ * cols_; i++)
            data_[i] *= b.data_[i];

        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x8c14
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
je 0x8c3b
movl $0x8, %edi
callq 0x20a0
movq %rax, %rdi
leaq 0x15fb(%rip), %rax      # 0xa223
movq %rax, (%rdi)
movq 0x737e(%rip), %rsi      # 0xffb0
xorl %eax, %eax
movl %eax, %edx
callq 0x21f0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %eax
movl 0x8(%rdx), %ecx
imull 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x8c97
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4490
movq -0x20(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4490
movss -0x24(%rbp), %xmm0
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8c42
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::fill(fill_type)
void fill(fill_type type)
    {
        assert(data_ != nullptr);
        switch(type)
        {
            case fill_type::RANDOM_FLOAT:
                for (int i = 0; i < rows_ * cols_; ++i)
                    data_[i] = get_random_float();
                break;
            case fill_type::SEQUENCE:
                for (int i = 0; i < rows_ * cols_; ++i)
                    data_[i] = i;
                break;
            case fill_type::ZERO:
                for (int i = 0; i < rows_ * cols_; ++i)
                    data_[i] = static_cast<T>(0);
                break;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x88e0
testb $0x1, %al
jne 0x914a
jmp 0x914c
jmp 0x916b
leaq 0x1032(%rip), %rdi      # 0xa185
leaq 0xf3e(%rip), %rsi       # 0xa098
movl $0x4e, %edx
leaq 0x10d2(%rip), %rcx      # 0xa238
callq 0x20d0
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x9192
jmp 0x9177
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x91e3
jmp 0x9181
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x922d
jmp 0x926b
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rdx
movl -0x10(%rbp), %eax
movl 0x8(%rdx), %ecx
imull 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x91de
movq -0x20(%rbp), %rdi
callq 0x9280
movq -0x20(%rbp), %rdi
movss %xmm0, -0x28(%rbp)
addq $0x10, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4490
movss -0x28(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9199
jmp 0x926b
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %eax
movl 0x8(%rdx), %ecx
imull 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x922b
movq -0x20(%rbp), %rdi
cvtsi2ssl -0x14(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4490
movss -0x2c(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x91ea
jmp 0x926b
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movl -0x18(%rbp), %eax
movl 0x8(%rdx), %ecx
imull 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x9269
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movslq -0x18(%rbp), %rsi
callq 0x4490
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9234
jmp 0x926b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: WojciechMula[P]utf16utf8/benchmarks/benchmark_from_utf16.cpp
// Function: main
int main() {
    // todo: Daniel finds the endless stream of numbers too much
    // Because some schemes use branching, you need to have a sizeable input if you
    // want fair results, given that we repeat the tests many times (we need to account
    // for branch predictors learning the branches).
    std::vector<size_t> input_size{16384};
    for (const size_t size: input_size) {
        Benchmark bench(size);
        bench.run_from_utf16();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1410, %rsp           # imm = 0x1410
movl $0x0, -0x4(%rbp)
movq $0x4000, -0x38(%rbp)    # imm = 0x4000
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x1408(%rbp)
callq 0xcb40
movq -0x1408(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xcb60
jmp 0xc624
leaq -0x39(%rbp), %rdi
callq 0xcbe0
leaq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xcc00
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0xcc30
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xcc60
testb $0x1, %al
jne 0xc665
jmp 0xc6eb
leaq -0x60(%rbp), %rdi
callq 0xcca0
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x1400(%rbp), %rdi
callq 0xccc0
jmp 0xc687
leaq -0x1400(%rbp), %rdi
callq 0xccf0
jmp 0xc695
leaq -0x1400(%rbp), %rdi
callq 0xd0b0
leaq -0x60(%rbp), %rdi
callq 0xd0d0
jmp 0xc64f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xcbe0
jmp 0xc709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xc700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x1400(%rbp), %rdi
callq 0xd0b0
jmp 0xc700
leaq -0x20(%rbp), %rdi
callq 0xd0f0
movl -0x4(%rbp), %eax
addq $0x1410, %rsp           # imm = 0x1410
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xd0f0
movq -0x48(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: cpottamus[P]btree_lab/makedisk.cc
// Function: main
int main(int argc, char *argv[])
{
  if (argc<10) { 
    usage();
    exit(-1);
  }

  DiskSystem disk(argv[1],
		  true,
		  0,
		  atoi(argv[2]),
		  atoi(argv[3]),
		  atoi(argv[4]),
		  atoi(argv[5]),
		  atoi(argv[6]),
		  atof(argv[7]),
		  atof(argv[8]),
		  atof(argv[9]));
  
  
  cerr << "Disk is as follows.\n" << disk << "\n";

  cerr << "Done.\n";

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x261e
callq 0x25d0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2290
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x23a0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
callq 0x2850
jmp 0x265c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2350
movl %eax, -0xf0(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2350
movl %eax, -0xec(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2350
movl %eax, -0xf4(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2350
movl %eax, -0xf8(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2350
movl %eax, -0xfc(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x22c0
movsd %xmm0, -0xe0(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x22c0
movsd %xmm0, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x22c0
movl -0xfc(%rbp), %esi
movl -0xf8(%rbp), %edx
movl -0xf4(%rbp), %ecx
movl -0xf0(%rbp), %r8d
movl -0xec(%rbp), %r9d
movsd -0xe8(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0xe0(%rbp), %xmm0
movq %rsp, %rax
movl %esi, 0x10(%rax)
movl %edx, 0x8(%rax)
movl %ecx, (%rax)
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2bd0
jmp 0x274c
leaq -0xb0(%rbp), %rdi
callq 0x2100
leaq -0xb1(%rbp), %rdi
callq 0x2220
movq 0x6885(%rip), %rdi      # 0x8ff0
leaq 0x38f2(%rip), %rsi      # 0x6064
callq 0x21b0
movq %rax, -0x108(%rbp)
jmp 0x2780
movq -0x108(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2900
movq %rax, -0x110(%rbp)
jmp 0x279c
movq -0x110(%rbp), %rdi
leaq 0x3aa2(%rip), %rsi      # 0x624c
callq 0x21b0
jmp 0x27b1
movq 0x6838(%rip), %rdi      # 0x8ff0
leaq 0x38ba(%rip), %rsi      # 0x6079
callq 0x21b0
jmp 0x27c6
movl $0x0, -0x4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3440
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x2817
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2100
leaq -0xb1(%rbp), %rdi
callq 0x2220
jmp 0x2843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3440
movq -0xc0(%rbp), %rdi
callq 0x2390
nop
// File: tokuhirom[P]nanouri/t/02_escape.cc
// Function: main
int main() {
    std::string src;

    src = "hello\x01\x02";
    is(nanouri::escape_uri(src), std::string("hello%01%02"), "escape");

    src = "hi\xff";
    is(nanouri::escape_uri(src), std::string("hi%ff"), "escape");

    done_testing();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x2260
movq -0xc8(%rbp), %rdi
leaq 0x109f(%rip), %rsi      # 0x4058
callq 0x2250
jmp 0x2fc0
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2450
jmp 0x2fcf
leaq -0x71(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x22e0
movq -0xd0(%rbp), %rdx
leaq 0x1073(%rip), %rsi      # 0x4060
leaq -0x70(%rbp), %rdi
callq 0x3170
jmp 0x2ff8
leaq 0x106d(%rip), %rdx      # 0x406c
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2a60
jmp 0x300e
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x71(%rbp), %rdi
callq 0x21e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq 0x1043(%rip), %rsi      # 0x4073
leaq -0x20(%rbp), %rdi
callq 0x2250
jmp 0x303b
leaq -0x98(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2450
jmp 0x304d
leaq -0xb9(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x22e0
movq -0xd8(%rbp), %rdx
leaq 0x1009(%rip), %rsi      # 0x4077
leaq -0xb8(%rbp), %rdi
callq 0x3170
jmp 0x307c
leaq 0xfe9(%rip), %rdx       # 0x406c
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x2a60
jmp 0x3098
leaq -0xb8(%rbp), %rdi
callq 0x20e0
leaq -0xb9(%rbp), %rdi
callq 0x21e0
leaq -0x98(%rbp), %rdi
callq 0x20e0
callq 0x2940
jmp 0x30c3
leaq -0x20(%rbp), %rdi
callq 0x20e0
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x315a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3108
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x71(%rbp), %rdi
callq 0x21e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
jmp 0x315a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3142
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x20e0
leaq -0xb9(%rbp), %rdi
callq 0x21e0
leaq -0x98(%rbp), %rdi
callq 0x20e0
leaq -0x20(%rbp), %rdi
callq 0x20e0
movq -0x28(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiInAlsa::~MidiInAlsa()
MidiInAlsa :: ~MidiInAlsa()
{
  // Close a connection if it exists.
  closePort();

  // Shutdown the input thread.
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
  if ( inputData_.doInput ) {
    inputData_.doInput = false;
    int res = write( data->trigger_fds[1], &inputData_.doInput, sizeof(inputData_.doInput) );
    (void) res;
    if ( !pthread_equal(data->thread, data->dummy_thread_id) )
      pthread_join( data->thread, NULL );
  }

  // Cleanup.
  close ( data->trigger_fds[0] );
  close ( data->trigger_fds[1] );
  if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport );
#ifndef AVOID_TIMESTAMPING
  snd_seq_free_queue( data->seq, data->queue_id );
#endif
  snd_seq_close( data->seq );
  delete data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0xf39d(%rip), %rax      # 0x1efa8
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0xfc1d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
testb $0x1, 0x89(%rax)
je 0xfc96
movq -0x20(%rbp), %rax
movq %rax, %rsi
addq $0x89, %rsi
movb $0x0, 0x89(%rax)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edi
movl $0x1, %edx
callq 0xd300
movq %rax, -0x28(%rbp)
jmp 0xfc5e
movq -0x28(%rbp), %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xe550
cmpl $0x0, %eax
jne 0xfc94
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd900
jmp 0xfc92
jmp 0xfc94
jmp 0xfc96
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %edi
callq 0xe790
jmp 0xfca4
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edi
callq 0xe790
jmp 0xfcb2
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jl 0xfccf
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl 0xc(%rax), %esi
callq 0xdd60
jmp 0xfccd
jmp 0xfccf
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl 0x48(%rax), %esi
callq 0xd610
jmp 0xfce0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xe060
jmp 0xfcee
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xfd0a
movq -0x30(%rbp), %rdi
movl $0x58, %esi
callq 0xda90
movq -0x20(%rbp), %rdi
callq 0xdee0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x12b40
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: portInfo(_snd_seq*, _snd_seq_port_info*, unsigned int, int)
unsigned int portInfo( snd_seq_t *seq, snd_seq_port_info_t *pinfo, unsigned int type, int portNumber )
{
  snd_seq_client_info_t *cinfo;
  int client;
  int count = 0;
  snd_seq_client_info_alloca( &cinfo );

  snd_seq_client_info_set_client( cinfo, -1 );
  while ( snd_seq_query_next_client( seq, cinfo ) >= 0 ) {
    client = snd_seq_client_info_get_client( cinfo );
    if ( client == 0 ) continue;
    // Reset query info
    snd_seq_port_info_set_client( pinfo, client );
    snd_seq_port_info_set_port( pinfo, -1 );
    while ( snd_seq_query_next_port( seq, pinfo ) >= 0 ) {
      unsigned int atyp = snd_seq_port_info_get_type( pinfo );
      if ( ( ( atyp & SND_SEQ_PORT_TYPE_MIDI_GENERIC ) == 0 ) &&
           ( ( atyp & SND_SEQ_PORT_TYPE_SYNTH ) == 0 ) &&
           ( ( atyp & SND_SEQ_PORT_TYPE_APPLICATION ) == 0 ) ) continue;
	    
      unsigned int caps = snd_seq_port_info_get_capability( pinfo );
      if ( ( caps & type ) != type ) continue;
      if ( count == portNumber ) return 1;
      ++count;
    }
  }

  // If a negative portNumber was used, return the port count.
  if ( portNumber < 0 ) return count;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
callq 0xe490
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xe490
movq -0x40(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0xd530
movq -0x28(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xdac0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe6d0
cmpl $0x0, %eax
jl 0x10126
movq -0x28(%rbp), %rdi
callq 0xd640
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x1008d
jmp 0x10063
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0xdf60
movq -0x18(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xd700
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd990
cmpl $0x0, %eax
jl 0x10121
movq -0x18(%rbp), %rdi
callq 0xe5c0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x100ec
movl -0x34(%rbp), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x100ec
movl -0x34(%rbp), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
jne 0x100ec
jmp 0x100a7
movq -0x18(%rbp), %rdi
callq 0xd740
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
andl -0x1c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x10105
jmp 0x100a7
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x10116
movl $0x1, -0x4(%rbp)
jmp 0x1013b
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x100a7
jmp 0x10063
cmpl $0x0, -0x20(%rbp)
jge 0x10134
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1013b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiInAlsa::closePort()
void MidiInAlsa :: closePort( void )
{
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);

  if ( connected_ ) {
    if ( data->subscription ) {
      snd_seq_unsubscribe_port( data->seq, data->subscription );
      snd_seq_port_subscribe_free( data->subscription );
      data->subscription = 0;
    }
    // Stop the input queue
#ifndef AVOID_TIMESTAMPING
    snd_seq_stop_queue( data->seq, data->queue_id, NULL );
    snd_seq_drain_output( data->seq );
#endif
    connected_ = false;
  }

  // Stop thread to avoid triggering the callback, while the port is intended to be closed
  if ( inputData_.doInput ) {
    inputData_.doInput = false;
    int res = write( data->trigger_fds[1], &inputData_.doInput, sizeof(inputData_.doInput) );
    (void) res;
    if ( !pthread_equal(data->thread, data->dummy_thread_id) )
      pthread_join( data->thread, NULL );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
testb $0x1, 0x10(%rax)
je 0x117fd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x117ca
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xe560
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xe1c0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x48(%rax), %esi
movl $0x20, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xdbe0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xe5b0
movq -0x20(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
testb $0x1, 0x89(%rax)
je 0x1185e
movq -0x20(%rbp), %rsi
movb $0x0, 0x89(%rsi)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edi
addq $0x50, %rsi
addq $0x39, %rsi
movl $0x1, %edx
callq 0xd300
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xe550
cmpl $0x0, %eax
jne 0x1185c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd900
jmp 0x1185e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiOutAlsa::~MidiOutAlsa()
MidiOutAlsa :: ~MidiOutAlsa()
{
  // Close a connection if it exists.
  closePort();

  // Cleanup.
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
  if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport );
  if ( data->coder ) snd_midi_event_free( data->coder );
  if ( data->buffer ) free( data->buffer );
  snd_seq_close( data->seq );
  delete data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0xd695(%rip), %rax      # 0x1ef90
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x1190d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jl 0x11936
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl 0xc(%rax), %esi
callq 0xdd60
jmp 0x11934
jmp 0x11936
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x11952
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xe580
jmp 0x11950
jmp 0x11952
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1196a
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xdd40
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xe060
jmp 0x11978
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x11994
movq -0x20(%rbp), %rdi
movl $0x58, %esi
callq 0xda90
movq -0x18(%rbp), %rdi
callq 0xd880
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x12b40
nopl (%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiOutAlsa::closePort()
void MidiOutAlsa :: closePort( void )
{
  if ( connected_ ) {
    AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
    snd_seq_unsubscribe_port( data->seq, data->subscription );
    snd_seq_port_subscribe_free( data->subscription );
    connected_ = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x10(%rax)
je 0x1262f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xe560
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xe1c0
movq -0x18(%rbp), %rax
movb $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiOutAlsa::openVirtualPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void MidiOutAlsa :: openVirtualPort( std::string portName )
{
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
  if ( data->vport < 0 ) {
    data->vport = snd_seq_create_simple_port( data->seq, portName.c_str(),
                                              SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ,
                                              SND_SEQ_PORT_TYPE_MIDI_GENERIC|SND_SEQ_PORT_TYPE_APPLICATION );

    if ( data->vport < 0 ) {
      errorString_ = "MidiOutAlsa::openVirtualPort: ALSA error creating virtual port.";
      error( RtMidiError::DRIVER_ERROR, errorString_ );
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jge 0x12710
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
callq 0xd3b0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl $0x21, %edx
movl $0x100002, %ecx         # imm = 0x100002
callq 0xe210
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jge 0x1270e
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x70(%rbp)
leaq 0x7045(%rip), %rsi      # 0x19707
callq 0xdfb0
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xd3d0
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rdx
movl $0x8, %esi
callq 0xd5f0
jmp 0x126ec
leaq -0x38(%rbp), %rdi
callq 0xd600
jmp 0x1270e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd600
jmp 0x12716
jmp 0x12710
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xe590
nop
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_get_compiled_api
int rtmidi_get_compiled_api (enum RtMidiApi **apis) // return length for NULL argument.
{
	if (!apis || !(*apis)) {
		std::vector<RtMidi::Api> *v = new std::vector<RtMidi::Api> ();
		try {
			RtMidi::getCompiledApi (*v);
			int size = v->size ();
			delete v;
			return size;
		} catch (...) {
			return -1;
		}
	} else {
		try {
			std::vector<RtMidi::Api> *v = new std::vector<RtMidi::Api> ();
			RtMidi::getCompiledApi (*v);
			for (unsigned int i = 0; i < v->size (); i++)
				(*apis) [i] = (RtMidiApi) v->at (i);
			delete v;
			return 0;
		} catch (...) {
			return -1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16f2d
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x16fa0
movl $0x18, %edi
callq 0xda40
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0xd530
movq -0x48(%rbp), %rdi
callq 0xdeb0
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd0c0
movq -0x18(%rbp), %rdi
callq 0xe460
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x16f95
movq -0x40(%rbp), %rdi
callq 0xe610
movq -0x40(%rbp), %rdi
movl $0x18, %esi
callq 0xda90
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1707e
movl $0x18, %edi
callq 0xda40
movq %rax, -0x50(%rbp)
jmp 0x16fb0
movq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0xd530
movq -0x50(%rbp), %rdi
callq 0xdeb0
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd0c0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe460
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x17052
movq -0x28(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
callq 0xe7c0
movq %rax, -0x60(%rbp)
jmp 0x17011
movq -0x60(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x38(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x16fe1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0xd3a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
callq 0xe360
jmp 0x1707e
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x17077
movq -0x68(%rbp), %rdi
callq 0xe610
movq -0x68(%rbp), %rdi
movl $0x18, %esi
callq 0xda90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_open_port
void rtmidi_open_port (RtMidiPtr device, unsigned int portNumber, const char *portName)
{
    std::string name = portName;
    try {
        ((RtMidi*) device->ptr)->openPort (portNumber, name);
    
    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xe5a0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xe4e0
jmp 0x171c4
leaq -0x39(%rbp), %rdi
callq 0xdba0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd3d0
jmp 0x171f3
movl -0x8c(%rbp), %esi
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
leaq -0x70(%rbp), %rdx
callq *%rax
jmp 0x1720e
leaq -0x70(%rbp), %rdi
callq 0xd600
jmp 0x17298
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xdba0
jmp 0x172bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17256
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xd600
movl -0x4c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x172b6
movq -0x48(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xe360
jmp 0x17296
jmp 0x17298
leaq -0x38(%rbp), %rdi
callq 0xd600
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd600
movq -0x48(%rbp), %rdi
callq 0xe590
nopl (%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_open_virtual_port
void rtmidi_open_virtual_port (RtMidiPtr device, const char *portName)
{
    std::string name = portName;
    try {
        ((RtMidi*) device->ptr)->openVirtualPort (name);
    
    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xe5a0
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xe4e0
jmp 0x1730b
leaq -0x31(%rbp), %rdi
callq 0xdba0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd3d0
jmp 0x17331
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq -0x68(%rbp), %rsi
callq *%rax
jmp 0x17347
leaq -0x68(%rbp), %rdi
callq 0xd600
jmp 0x173d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0xdba0
jmp 0x173f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1738f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xd600
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x173ef
movq -0x40(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xe360
jmp 0x173cf
jmp 0x173d1
leaq -0x30(%rbp), %rdi
callq 0xd600
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd600
movq -0x40(%rbp), %rdi
callq 0xe590
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_close_port
void rtmidi_close_port (RtMidiPtr device)
{
    try { 
        ((RtMidi*) device->ptr)->closePort ();

    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x1742e
jmp 0x17477
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1747d
movq -0x10(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xe360
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xe590
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_get_port_count
unsigned int rtmidi_get_port_count (RtMidiPtr device)
{
    try {
        return ((RtMidi*) device->ptr)->getPortCount ();

    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0x2c(%rbp)
jmp 0x174b1
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17507
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x17510
movq -0x18(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
callq 0xe360
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xe590
nopl (%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_get_port_name
const char* rtmidi_get_port_name (RtMidiPtr device, unsigned int portNumber)
{
    try {
        std::string name = ((RtMidi*) device->ptr)->getPortName (portNumber);
        return strdup (name.c_str ());
    
    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
        return "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x38(%rbp), %rdi
callq *%rax
jmp 0x17548
leaq -0x38(%rbp), %rdi
callq 0xd3b0
movq %rax, %rdi
callq 0xe670
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd600
jmp 0x175ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x175c4
movq -0x40(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0x23ea(%rip), %rax      # 0x1999b
movq %rax, -0x8(%rbp)
callq 0xe360
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xe590
nopl (%rax)