LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xbai0624[P]dnn/src/Neuron.cpp
// Function: Neuron::__softmax(Matrix&)
double Neuron::__softmax(Matrix &m_z)
{
    if(__layer->GetType() != LayerType::output)
    {
        // soft max is usually used in output layer, it is rare in hidden layer
        // print a warning if the neuron detected layertype not = output
        std::cout<<__func__<<" Warning: using softmax in hidden layers? please make sure."
            <<std::endl;
    }
    auto dim = m_z.Dimension();
    assert(dim.second == 1);

    size_t i = __coord.i;
    assert(dim.first > i);

    double sum = 0;
    for(size_t k = 0;k<dim.first;k++)
    {
        sum += exp((double)m_z[k][0]);
    }

    return exp(m_z[i][0])/sum;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x250(%rax)
cmpl $0x4, %eax
je 0x47dfb
movq 0x23207(%rip), %rdi     # 0x6afd8
leaq 0xdbb8(%rip), %rsi      # 0x55990
callq 0x4230
movq %rax, %rdi
leaq 0xdbb3(%rip), %rsi      # 0x5599a
callq 0x4230
movq %rax, %rdi
movq 0x231ba(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x38(%rsp), %rdi
callq 0x3bae0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
cmpq $0x1, 0x30(%rsp)
jne 0x47e19
jmp 0x47e38
leaq 0xad22(%rip), %rdi      # 0x52b42
leaq 0xdbaf(%rip), %rsi      # 0x559d6
movl $0x45, %edx
leaq 0xdbb2(%rip), %rcx      # 0x559e5
callq 0x4170
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x47e57
jmp 0x47e76
leaq 0xdbaa(%rip), %rdi      # 0x55a08
leaq 0xdb71(%rip), %rsi      # 0x559d6
movl $0x48, %edx
leaq 0xdb74(%rip), %rcx      # 0x559e5
callq 0x4170
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x47ed4
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1fd60
movsd (%rax), %xmm0
callq 0x4420
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x47e88
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3be50
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1fd60
movsd (%rax), %xmm0
callq 0x4420
divsd 0x18(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: xbai0624[P]dnn/src/Neuron.cpp
// Function: Neuron::Reset()
void Neuron::Reset()
{
    if(__layer == nullptr)
    {
        std::cout<<"Error: Neuron::Reset(): the layer info has not been set for this neuron."
            <<endl;
        exit(0);
    }
    int batch_size = __layer->GetBatchSize();
    // after updateing weights and biase, 
    // namely after one training (one sample or one batch depends on user)
    // reset neurons for next computation
    __a.clear();
    __a.resize(batch_size); // reset a
    __delta.clear();
    __delta.resize(batch_size); // reset delta
    __z.clear();
    __z.resize(batch_size); // reset z
    __sigmaPrime.clear();
    __sigmaPrime.resize(batch_size);

    //__wGradient.clear(); // reset weight gradient
    //__bGradient.clear(); // reset bias gradient
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x78(%rax)
jne 0x48042
movq 0x22fb8(%rip), %rdi     # 0x6afd8
leaq 0xd9ef(%rip), %rsi      # 0x55a16
callq 0x4230
movq %rax, %rdi
movq 0x22f7a(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x2a0(%rax)
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
callq 0x21770
movq (%rsp), %rdi
addq $0x18, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1f3c0
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x21770
movq (%rsp), %rdi
addq $0x30, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1f3c0
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0x21770
movq (%rsp), %rdi
addq $0x48, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1f3c0
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0x21770
movq (%rsp), %rdi
addq $0x60, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1f3c0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: xbai0624[P]dnn/src/Neuron.cpp
// Function: Neuron::ClearPreviousBatch()
void Neuron::ClearPreviousBatch()
{
    __a.clear();           // necessary, since resize won't overwrite old contents
    __delta.clear();       // 
    __z.clear();           // 
    __sigmaPrime.clear();  // 

    if(__layer == nullptr)
    {
        std::cout<<"Error: Neuron::ClearPreviousBatch(): the layer info has not been set for this neuron."
            <<endl;
        exit(0);
    }
    int batch_size = __layer->GetBatchSize();
    __a.resize(batch_size); // reset a
    __delta.resize(batch_size); // reset delta
    __z.resize(batch_size); // reset z
    __sigmaPrime.resize(batch_size);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x18, %rdi
callq 0x21770
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x21770
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0x21770
movq (%rsp), %rdi
addq $0x60, %rdi
callq 0x21770
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x4a366
movq 0x20c94(%rip), %rdi     # 0x6afd8
leaq 0xbfbc(%rip), %rsi      # 0x56307
callq 0x4230
movq %rax, %rdi
movq 0x20c56(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %edi, %edi
callq 0x4290
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rdi), %rax
callq *0x2a0(%rax)
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1f3c0
movq (%rsp), %rdi
addq $0x30, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1f3c0
movq (%rsp), %rdi
addq $0x48, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1f3c0
movq (%rsp), %rdi
addq $0x60, %rdi
movslq 0xc(%rsp), %rsi
callq 0x1f3c0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: xbai0624[P]dnn/src/Neuron.cpp
// Function: Neuron::Print()
void Neuron::Print()
{
    std::cout<<"--------------------------------------"<<std::endl;
    std::cout<<"neuron id: "<<__neuron_id<<std::endl;
    std::cout<<"active status: "<<__active_status<<std::endl;
    if(!__active_status) return;
    std::cout<<"w matrix: "<<std::endl;
    std::cout<<(*__w);
    std::cout<<"bias: "<<std::endl;
    std::cout<<(*__b);
    std::cout<<"Neruon Coord: "<<endl;
    std::cout<<__coord<<endl;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20bee(%rip), %rdi     # 0x6afd8
leaq 0xbf6c(%rip), %rsi      # 0x5635d
callq 0x4230
movq %rax, %rdi
movq 0x20bb0(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x20bcc(%rip), %rdi     # 0x6afd8
leaq 0xbf71(%rip), %rsi      # 0x56384
callq 0x4230
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x4430
movq %rax, %rdi
movq 0x20b7e(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x20b9a(%rip), %rdi     # 0x6afd8
leaq 0xbf4b(%rip), %rsi      # 0x56390
callq 0x4230
movq %rax, %rdi
movq 0x8(%rsp), %rax
movb 0x80(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4410
movq %rax, %rdi
movq 0x20b44(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x8(%rsp), %rax
testb $0x1, 0x80(%rax)
jne 0x4a484
jmp 0x4a53b
movq 0x20b4d(%rip), %rdi     # 0x6afd8
leaq 0xbf0e(%rip), %rsi      # 0x563a0
callq 0x4230
movq %rax, %rdi
movq 0x20b0f(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20b22(%rip), %rdi     # 0x6afd8
callq 0x3d640
movq 0x20b16(%rip), %rdi     # 0x6afd8
leaq 0xbee2(%rip), %rsi      # 0x563ab
callq 0x4230
movq %rax, %rdi
movq 0x20ad8(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20aeb(%rip), %rdi     # 0x6afd8
callq 0x3d640
movq 0x20adf(%rip), %rdi     # 0x6afd8
leaq 0xbeb2(%rip), %rsi      # 0x563b2
callq 0x4230
movq %rax, %rdi
movq 0x20aa1(%rip), %rsi     # 0x6afb0
callq 0x4260
movq 0x8(%rsp), %rsi
addq $0x88, %rsi
movq 0x20ab1(%rip), %rdi     # 0x6afd8
callq 0x3ad60
movq %rax, %rdi
movq 0x20a7a(%rip), %rsi     # 0x6afb0
callq 0x4260
addq $0x18, %rsp
retq
// File: xbai0624[P]dnn/src/UnitTest.cpp
// Function: UnitTest::TestFilter2D()
void UnitTest::TestFilter2D()
{
    /*
    Filter2D F(4, 4);
    cout<<F<<endl;

    Filter2D f = F;
    cout<<f<<endl;

    // test default assign
    vector<vector<bool>> b(4, vector<bool>(4, true));
    vector<vector<bool>> c;
    c = b;

    for(auto i: c)
    {
        for(auto j: i)
            cout<<j<<", ";
        cout<<endl;
    }

    // test default assignment
    vector<Filter2D> VF;
    VF.resize(4, Filter2D(3, 3));
    vector<Filter2D> VFC;
    VFC = VF;

    for(auto &i: VFC)
        cout<<i<<endl;


    Filter2D notF = F.Opposite();
    cout<<"-------------------"<<endl;
    cout<<F<<endl;
    cout<<notF<<endl;
    */
    cout<<"++++++++++++++++++++++++++++++++++"<<endl;
    //Filter2D FF(100, 100, true);
    //vector<Filter2D> complete_set = FF.GenerateCompleteDropOutSet(3, 0.4);
    //for(auto &i: complete_set) cout<<i<<endl;

    Filter2D FF(10, 1, true);
    vector<Filter2D> complete_set = FF.GenerateCompleteDropOutSet(20, 0.5);
    for(auto &i: complete_set) 
        cout<<i<<endl;


    //Filter2D FF(500, 500, true);
    //vector<Filter2D> complete_set = FF.GenerateCompleteDropOutSet(4, 0.33333);
    //for(auto &i: complete_set)  cout<<i<<endl;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x20508(%rip), %rdi     # 0x6afd8
leaq 0xb8ea(%rip), %rsi      # 0x563c1
callq 0x4230
movq %rax, %rdi
movq 0x204ca(%rip), %rsi     # 0x6afb0
callq 0x4260
leaq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xa, %esi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x27a60
movq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x14, %edx
movsd 0x74f0(%rip), %xmm0     # 0x52010
callq 0x201f0
jmp 0x4ab27
leaq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x20140
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x20170
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x201a0
testb $0x1, %al
jne 0x4ab64
jmp 0x4abd4
leaq 0x20(%rsp), %rdi
callq 0x201e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq 0x20459(%rip), %rdi     # 0x6afd8
callq 0x3ac20
movq %rax, (%rsp)
jmp 0x4ab8a
movq (%rsp), %rdi
movq 0x2041b(%rip), %rsi     # 0x6afb0
callq 0x4260
jmp 0x4ab9c
jmp 0x4ab9e
leaq 0x20(%rsp), %rdi
callq 0x20b60
jmp 0x4ab4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x4abed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1f250
jmp 0x4abed
leaq 0x40(%rsp), %rdi
callq 0x1f250
leaq 0x58(%rsp), %rdi
callq 0x1f9b0
addq $0x78, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0x1f9b0
movq 0x38(%rsp), %rdi
callq 0x43f0
nopw %cs:(%rax,%rax)
// File: xbai0624[P]dnn/src/main.cpp
// Function: main
int main(int argc, char* argv[])
{
    feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
    Network *net_work = new Network();
    net_work->Init();

    net_work->Train();
    //net_work->Classify();

    // test
    //UnitTest *test = new UnitTest();
    //test->Test();

    cout<<"MAIN TEST SUCCESS!!!"<<endl;
    return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xd, %edi
callq 0x40c0
movl $0x38, %edi
callq 0x4240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x45260
jmp 0x51a3b
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x452c0
movq 0x20(%rsp), %rdi
callq 0x45d30
movq 0x19578(%rip), %rdi     # 0x6afd8
leaq 0x4fa6(%rip), %rsi      # 0x56a0d
callq 0x4230
movq %rax, %rdi
movq 0x1953a(%rip), %rsi     # 0x6afb0
callq 0x4260
xorl %eax, %eax
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x4220
movq 0x18(%rsp), %rdi
callq 0x43f0
// File: fuad00[P]wifitool/code.cpp
// Function: progress(int)
bool progress(int progress) {
	system("clear");
	cout << "\n[";
	int pos = progress / 2;
	for (int i = 0; i < 50; ++i) {
		if (i < pos) cout << "=";
		else if (i == pos) cout << ">";
		else cout << " ";
	}
	cout << "] " << int(progress) << " %\r";
	cout.flush();
	current_progress = progress; // Запоминаем значение аргумента полосы прогресса
	cout << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2f3b(%rip), %rdi      # 0x5b7d
callq 0x2170
movq 0x6382(%rip), %rdi      # 0x8fd0
leaq 0x2f36(%rip), %rsi      # 0x5b8b
callq 0x21b0
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x32, -0xc(%rbp)
jge 0x2cd1
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2c92
movq 0x634c(%rip), %rdi      # 0x8fd0
leaq 0x2f03(%rip), %rsi      # 0x5b8e
callq 0x21b0
jmp 0x2cc4
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x2caf
movq 0x632f(%rip), %rdi      # 0x8fd0
leaq 0x2ee8(%rip), %rsi      # 0x5b90
callq 0x21b0
jmp 0x2cc2
movq 0x631a(%rip), %rdi      # 0x8fd0
leaq 0x2b3f(%rip), %rsi      # 0x57fc
callq 0x21b0
jmp 0x2cc4
jmp 0x2cc6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2c6f
movq 0x62f8(%rip), %rdi      # 0x8fd0
leaq 0x2eb3(%rip), %rsi      # 0x5b92
callq 0x21b0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x22c0
movq %rax, %rdi
leaq 0x2e9c(%rip), %rsi      # 0x5b95
callq 0x21b0
movq 0x62cb(%rip), %rdi      # 0x8fd0
callq 0x2110
movl -0x4(%rbp), %eax
movl %eax, 0x64b9(%rip)      # 0x91cc
movq 0x62b6(%rip), %rdi      # 0x8fd0
movq 0x6287(%rip), %rsi      # 0x8fa8
callq 0x21e0
xorl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: fuad00[P]wifitool/code.cpp
// Function: help_func()
int help_func()	{
	progress(current_progress);    // Выводим АКТУАЛЬНУЮ строку прогресса

	cout << "\n[1] Для проверки и установки необходимых компонентов." << endl;
	cout << "[2] Для перевода сетевой карты в режим монитора." << endl;
	cout << "[3] Для прослушки сетей." << endl;
	cout << "[4] Для перехвата хендшейка." << endl;
	cout << "[5] Для перебора пароля\n" << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x6492(%rip), %edi      # 0x91cc
callq 0x2c30
movq 0x628a(%rip), %rdi      # 0x8fd0
leaq 0x25fb(%rip), %rsi      # 0x5348
callq 0x21b0
movq %rax, %rdi
movq 0x624c(%rip), %rsi      # 0x8fa8
callq 0x21e0
movq 0x6268(%rip), %rdi      # 0x8fd0
leaq 0x263b(%rip), %rsi      # 0x53aa
callq 0x21b0
movq %rax, %rdi
movq 0x622a(%rip), %rsi      # 0x8fa8
callq 0x21e0
movq 0x6246(%rip), %rdi      # 0x8fd0
leaq 0x266f(%rip), %rsi      # 0x5400
callq 0x21b0
movq %rax, %rdi
movq 0x6208(%rip), %rsi      # 0x8fa8
callq 0x21e0
movq 0x6224(%rip), %rdi      # 0x8fd0
leaq 0x2677(%rip), %rsi      # 0x542a
callq 0x21b0
movq %rax, %rdi
movq 0x61e6(%rip), %rsi      # 0x8fa8
callq 0x21e0
movq 0x6202(%rip), %rdi      # 0x8fd0
leaq 0x2687(%rip), %rsi      # 0x545c
callq 0x21b0
movq %rax, %rdi
movq 0x61c4(%rip), %rsi      # 0x8fa8
callq 0x21e0
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: fuad00[P]wifitool/code.cpp
// Function: check_func()
bool check_func()	{
	progress(5);              // Выводим строку прогресса
	cout << "\nПроверка необходимых компонентов....." << endl;
	if (system("which aircrack-ng > /dev/null 2>&1"))	{      // Если компонент отсутствует в системе
		system("apt-get update && apt-get install -y aircrack-ng");         // Устанавливаем компонент
		check_func();     // Перезапускаем функцию проверки чтобы убедиться, что компонент установился
	}

	else if (system("which xterm > /dev/null 2>&1"))	{
		system("apt-get update && apt-get install -y xterm");
		check_func();
	}
	else	{
	progress(10);             // Выводим строку прогресса
	cout << "\n[!] Все компоненты уже установлены! Можете продолжать работу.\n" << endl;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x5, %edi
callq 0x2c30
movq 0x61cb(%rip), %rdi      # 0x8fd0
leaq 0x267a(%rip), %rsi      # 0x5486
callq 0x21b0
movq %rax, %rdi
movq 0x618d(%rip), %rsi      # 0x8fa8
callq 0x21e0
leaq 0x26a4(%rip), %rdi      # 0x54cb
callq 0x2170
cmpl $0x0, %eax
je 0x2e44
leaq 0x26b6(%rip), %rdi      # 0x54ee
callq 0x2170
callq 0x2df0
jmp 0x2e96
leaq 0x26d4(%rip), %rdi      # 0x551f
callq 0x2170
cmpl $0x0, %eax
je 0x2e68
leaq 0x26e0(%rip), %rdi      # 0x553c
callq 0x2170
callq 0x2df0
jmp 0x2e94
movl $0xa, %edi
callq 0x2c30
movq 0x6157(%rip), %rdi      # 0x8fd0
leaq 0x26e7(%rip), %rsi      # 0x5567
callq 0x21b0
movq %rax, %rdi
movq 0x6119(%rip), %rsi      # 0x8fa8
callq 0x21e0
jmp 0x2e96
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: fuad00[P]wifitool/code.cpp
// Function: monitor_func()
bool monitor_func()	{
	progress(15);      // Выводим строку прогресса
	system("xterm -title 'Переводим карту в режим монитора...' -e sudo airmon-ng check kill > /dev/null 2>&1"); // Убиваем все процессы (демоны), которые используются на данный момент сетевой картой
	progress(20);      // Выводим строку прогресса
	string monitor_mode = "xterm -title 'Переводим карту в режим монитора...' -e sudo airmon-ng start " + wireless_card + " > /dev/null 2>&1"; //пробуем перевести выбранную? карту в режим монитора
	const char *firing_command_monitor_mode = monitor_mode.c_str();
	system(firing_command_monitor_mode);
	progress(25);      // Выводим строку прогресса
	cout << "\n[+] Готово! Используйте [3] чтобы понюхать WiFi.\n" << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0xf, %edi
callq 0x2c30
leaq 0x271f(%rip), %rdi      # 0x55d8
callq 0x2170
movl $0x14, %edi
callq 0x2c30
leaq 0x2786(%rip), %rsi      # 0x5655
leaq 0x630a(%rip), %rdx      # 0x91e0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3c50
movq -0x60(%rbp), %rsi
leaq 0x25ee(%rip), %rdx      # 0x54dc
leaq -0x20(%rbp), %rdi
callq 0x3bb0
jmp 0x2ef9
leaq -0x40(%rbp), %rdi
callq 0x2358
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x2170
jmp 0x2f1a
movl $0x19, %edi
callq 0x2c30
jmp 0x2f26
movq 0x60a3(%rip), %rdi      # 0x8fd0
leaq 0x2789(%rip), %rsi      # 0x56bd
callq 0x21b0
movq %rax, -0x68(%rbp)
jmp 0x2f3f
movq -0x68(%rbp), %rdi
movq 0x605e(%rip), %rsi      # 0x8fa8
callq 0x21e0
jmp 0x2f51
leaq -0x20(%rbp), %rdi
callq 0x2358
xorl %eax, %eax
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2358
jmp 0x2f90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2358
movq -0x48(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: fuad00[P]wifitool/code.cpp
// Function: sniff_real_func()
bool sniff_real_func()	{
	string airodump1 = "timeout 9 xterm -title 'Поиск WiFi...' -e sudo airodump-ng " + wireless_card_monitormode + " --output-format=csv -w nets.csv --write-interval 3";
	const char *airodump_init1 = airodump1.c_str();
	system(airodump_init1);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x2b16(%rip), %rsi      # 0x5ac5
leaq 0x626a(%rip), %rdx      # 0x9220
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3c50
movq -0x60(%rbp), %rsi
leaq 0x2b38(%rip), %rdx      # 0x5b06
leaq -0x20(%rbp), %rdi
callq 0x3bb0
jmp 0x2fd9
leaq -0x40(%rbp), %rdi
callq 0x2358
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x2170
jmp 0x2ffa
leaq -0x20(%rbp), %rdi
callq 0x2358
xorl %eax, %eax
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2358
jmp 0x3039
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2358
movq -0x48(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: fuad00[P]wifitool/code.cpp
// Function: deauth_func()
bool deauth_func()	{
	string airodump2 = "xterm -hold -title 'Слушаем канал...' -e sudo airodump-ng " + wireless_card_monitormode + " --bssid='" + target_bssid + "' -c " + target_channel_number + " -w tmp/'" + target_name + "'.cap";
	const char *airodump_sniff_selected_ap = airodump2.c_str();
	system(airodump_sniff_selected_ap);  // Запуск команды для прослушки канала
	// TODO: Автоматом понять, что хендшейк пойман (у fluxion есть реализация)
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
leaq 0x2470(%rip), %rsi      # 0x5992
leaq 0x5cf7(%rip), %rdx      # 0x9220
leaq -0x100(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x3c50
movq -0x120(%rbp), %rsi
leaq 0x248f(%rip), %rdx      # 0x59d9
leaq -0xe0(%rbp), %rdi
callq 0x3bb0
jmp 0x3558
leaq 0x5da9(%rip), %rdx      # 0x9308
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x3c00
jmp 0x3574
leaq 0x2469(%rip), %rdx      # 0x59e4
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x3bb0
jmp 0x3590
leaq 0x5cf1(%rip), %rdx      # 0x9288
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3c00
jmp 0x35a9
leaq 0x243a(%rip), %rdx      # 0x59ea
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3bb0
jmp 0x35bf
leaq 0x5d82(%rip), %rdx      # 0x9348
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3c00
jmp 0x35d5
leaq 0x2418(%rip), %rdx      # 0x59f4
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3bb0
jmp 0x35eb
leaq -0x40(%rbp), %rdi
callq 0x2358
leaq -0x60(%rbp), %rdi
callq 0x2358
leaq -0x80(%rbp), %rdi
callq 0x2358
leaq -0xa0(%rbp), %rdi
callq 0x2358
leaq -0xc0(%rbp), %rdi
callq 0x2358
leaq -0xe0(%rbp), %rdi
callq 0x2358
leaq -0x100(%rbp), %rdi
callq 0x2358
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
callq 0x2170
jmp 0x3654
leaq -0x20(%rbp), %rdi
callq 0x2358
xorl %eax, %eax
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x3739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x372d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x3721
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x3715
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x370c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x3703
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2358
leaq -0x60(%rbp), %rdi
callq 0x2358
leaq -0x80(%rbp), %rdi
callq 0x2358
leaq -0xa0(%rbp), %rdi
callq 0x2358
leaq -0xc0(%rbp), %rdi
callq 0x2358
leaq -0xe0(%rbp), %rdi
callq 0x2358
leaq -0x100(%rbp), %rdi
callq 0x2358
jmp 0x3762
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2358
movq -0x108(%rbp), %rdi
callq 0x22e0
nop
// File: fuad00[P]wifitool/code.cpp
// Function: animation()
bool animation() {

	for(int t=0; t<15; t++)	{
		string channel_anim = " Настраиваем сетевой канал";

		cout << "[)]" << channel_anim << "." << endl;
		system("sleep 0.1 && clear");
		cout << "[|]" << channel_anim << ".." << endl;
		system("sleep 0.1 && clear");
		cout << "[(]" << channel_anim << "..." << endl;
		system("sleep 0.1 && clear");
		cout << "[|]" << channel_anim << ".." << endl;
		system("sleep 0.1 && clear");

	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0xf, -0x4(%rbp)
jge 0x39a3
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x22f0
movq -0x48(%rbp), %rdx
leaq 0x2396(%rip), %rsi      # 0x5b3a
leaq -0x28(%rbp), %rdi
callq 0x3b00
jmp 0x37af
leaq -0x29(%rbp), %rdi
callq 0x2200
movq 0x5811(%rip), %rdi      # 0x8fd0
leaq 0x23a6(%rip), %rsi      # 0x5b6c
callq 0x21b0
movq %rax, -0x50(%rbp)
jmp 0x37d1
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2190
movq %rax, -0x58(%rbp)
jmp 0x37e4
movq -0x58(%rbp), %rdi
leaq 0x22c1(%rip), %rsi      # 0x5ab0
callq 0x21b0
movq %rax, -0x60(%rbp)
jmp 0x37fa
movq -0x60(%rbp), %rdi
movq 0x57a3(%rip), %rsi      # 0x8fa8
callq 0x21e0
jmp 0x380c
leaq 0x235d(%rip), %rdi      # 0x5b70
callq 0x2170
jmp 0x381a
movq 0x57af(%rip), %rdi      # 0x8fd0
leaq 0x235b(%rip), %rsi      # 0x5b83
callq 0x21b0
movq %rax, -0x68(%rbp)
jmp 0x3833
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2190
movq %rax, -0x70(%rbp)
jmp 0x3846
movq -0x70(%rbp), %rdi
leaq 0x1c77(%rip), %rsi      # 0x54c8
callq 0x21b0
movq %rax, -0x78(%rbp)
jmp 0x385c
movq -0x78(%rbp), %rdi
movq 0x5741(%rip), %rsi      # 0x8fa8
callq 0x21e0
jmp 0x386e
leaq 0x22fb(%rip), %rdi      # 0x5b70
callq 0x2170
jmp 0x387c
movq 0x574d(%rip), %rdi      # 0x8fd0
leaq 0x22fd(%rip), %rsi      # 0x5b87
callq 0x21b0
movq %rax, -0x80(%rbp)
jmp 0x3895
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2190
movq %rax, -0x88(%rbp)
jmp 0x38ab
movq -0x88(%rbp), %rdi
leaq 0x1c0e(%rip), %rsi      # 0x54c7
callq 0x21b0
movq %rax, -0x90(%rbp)
jmp 0x38c7
movq -0x90(%rbp), %rdi
movq 0x56d3(%rip), %rsi      # 0x8fa8
callq 0x21e0
jmp 0x38dc
leaq 0x228d(%rip), %rdi      # 0x5b70
callq 0x2170
jmp 0x38ea
movq 0x56df(%rip), %rdi      # 0x8fd0
leaq 0x228b(%rip), %rsi      # 0x5b83
callq 0x21b0
movq %rax, -0x98(%rbp)
jmp 0x3906
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2190
movq %rax, -0xa0(%rbp)
jmp 0x391f
movq -0xa0(%rbp), %rdi
leaq 0x1b9b(%rip), %rsi      # 0x54c8
callq 0x21b0
movq %rax, -0xa8(%rbp)
jmp 0x393b
movq -0xa8(%rbp), %rdi
movq 0x565f(%rip), %rsi      # 0x8fa8
callq 0x21e0
jmp 0x3950
leaq 0x2219(%rip), %rdi      # 0x5b70
callq 0x2170
jmp 0x395e
leaq -0x28(%rbp), %rdi
callq 0x2358
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3782
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2200
jmp 0x39b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2358
jmp 0x39b0
xorl %eax, %eax
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: fuad00[P]wifitool/code.cpp
// Function: deauth_func2()
bool deauth_func2()	{
	string airplay_deauth = "xterm -title 'Глушим сеть...' -e sudo aireplay-ng --deauth 7 -a " + target_bssid + " " + wireless_card_monitormode; // -c Client_MAC
	const char *deauther = airplay_deauth.c_str();
	system(deauther); // Запуск команды для деаута клиентов
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x2028(%rip), %rsi      # 0x59fa
leaq 0x592f(%rip), %rdx      # 0x9308
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3c50
movq -0x80(%rbp), %rsi
leaq 0x1e0b(%rip), %rdx      # 0x57fc
leaq -0x40(%rbp), %rdi
callq 0x3bb0
jmp 0x39fc
leaq 0x581d(%rip), %rdx      # 0x9220
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3c00
jmp 0x3a12
leaq -0x40(%rbp), %rdi
callq 0x2358
leaq -0x60(%rbp), %rdi
callq 0x2358
leaq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x2170
jmp 0x3a3c
leaq -0x20(%rbp), %rdi
callq 0x2358
xorl %eax, %eax
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3a75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2358
leaq -0x60(%rbp), %rdi
callq 0x2358
jmp 0x3a95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2358
movq -0x68(%rbp), %rdi
callq 0x22e0
nop
// File: fuad00[P]wifitool/code.cpp
// Function: crack_func()
bool crack_func()	{
	system("xterm -hold -title 'Перебор пароля...' -e sudo aircrack-ng -w list.txt tmp/*.cap"); // Запуск команды для перебора
	system("cp tmp/*.cap ."); // Копируем рукопожатие
	progress(100);            // Выводим строку прогресса
	cout << "\nProgram finished!" << endl;
	system(start_func);       // Запуск команды для отчистки
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1f9a(%rip), %rdi      # 0x5a45
callq 0x2170
leaq 0x1fec(%rip), %rdi      # 0x5aa3
callq 0x2170
movl $0x64, %edi
callq 0x2c30
movq 0x5503(%rip), %rdi      # 0x8fd0
leaq 0x1fde(%rip), %rsi      # 0x5ab2
callq 0x21b0
movq %rax, %rdi
movq 0x54c5(%rip), %rsi      # 0x8fa8
callq 0x21e0
movq 0x5751(%rip), %rdi      # 0x9240
callq 0x2170
xorl %eax, %eax
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: Mesh::getTriangles() const
std::vector<vec3> Mesh::getTriangles() const
{
    std::vector<vec3> vList;
    for(auto it=triangles.begin(); it!=triangles.end(); it++)
    {
        vList.push_back(vertices[halfEdges[it->eIndices[0]].vIndices[0]].pos);
        vList.push_back(vertices[halfEdges[it->eIndices[1]].vIndices[0]].pos);
        vList.push_back(vertices[halfEdges[it->eIndices[2]].vIndices[0]].pos);
    }
    return vList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4110
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x4130
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x41a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4160
testb $0x1, %al
jne 0x13e7
jmp 0x1500
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x60(%rbp)
addq $0x40, %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4280
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x4260
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x4240
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x41d0
jmp 0x1433
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x70(%rbp)
addq $0x40, %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4280
movq -0x78(%rbp), %rdi
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x4260
movq -0x70(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x4240
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x41d0
jmp 0x1480
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x80(%rbp)
addq $0x40, %rax
movq %rax, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4280
movq -0x88(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x4260
movq -0x80(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x4240
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x41d0
jmp 0x14d3
jmp 0x14d5
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x42a0
movq %rax, -0x40(%rbp)
jmp 0x13c0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x42e0
jmp 0x1520
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1513
movq -0x58(%rbp), %rdi
callq 0x42e0
movq -0x50(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x11c0
nopl (%rax)
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: Mesh::inTriangle(unsigned int, glm::detail::tvec3<double, (glm::precision)0> const&) const
bool Mesh::inTriangle(unsigned triIndex, const vec3& pos) const
{
    bool projCond = false;
    for(int i=0; i<3; i++)
    {
        vec3 v[2];
        const HalfEdge& e = halfEdges[triangles[triIndex].eIndices[i]];
        v[0] = vertices[e.vIndices[0]].pos;
        v[1] = vertices[e.vIndices[1]].pos;
        if(orient(v[0], v[1], pos)<0)
            return false;
        real projDist = glm::dot(pos-v[0], glm::normalize(v[1]-v[0]));
        if(projDist >= 0 && projDist < glm::length(v[1] - v[0]))
            projCond = true;
    }
    return projCond;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movb $0x0, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x2337
leaq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0xe8(%rbp)
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x43a0
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rcx
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0xe0(%rbp)
jne 0x217f
movq -0xd8(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0xf8(%rbp)
addq $0x28, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x52c0
movq -0xf8(%rbp), %rdi
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x4260
movq -0xd8(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x10, %rdi
movq -0x68(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x4240
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
callq 0x4790
movq -0xd8(%rbp), %rdi
addq $0x10, %rdi
movq -0x68(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x4240
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0x4790
leaq -0x60(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0x52e0
cmpl $0x0, %eax
jge 0x2264
movb $0x0, -0x1(%rbp)
jmp 0x233f
movq -0x20(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x4650
leaq -0x60(%rbp), %rsi
addq $0x18, %rsi
leaq -0x60(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
callq 0x4650
leaq -0xa0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x53c0
leaq -0x88(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5390
movsd %xmm0, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0xf9(%rbp)
jb 0x2317
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x108(%rbp)
leaq -0x60(%rbp), %rsi
addq $0x18, %rsi
leaq -0x60(%rbp), %rdx
leaq -0xd0(%rbp), %rdi
callq 0x4650
leaq -0xd0(%rbp), %rdi
callq 0x45e0
movsd -0x108(%rbp), %xmm1
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0xf9(%rbp)
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x2323
jmp 0x2327
movb $0x1, -0x21(%rbp)
jmp 0x2329
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x215c
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: Mesh::intersectRatio(unsigned int, glm::detail::tvec3<double, (glm::precision)0> const&, glm::detail::tvec3<double, (glm::precision)0> const&) const
real Mesh::intersectRatio(unsigned eIndex, const vec3& searchPos, const vec3& pos) const
{
    const vec3& v0 = vertices[halfEdges[eIndex].vIndices[0]].pos;
    const vec3& v1 = vertices[halfEdges[eIndex].vIndices[1]].pos;
    vec3 dv = v1 - v0;
    vec3 dp = -pos + searchPos;
    vec3 rhs = searchPos - v0;
    real down = dv.x * dp.y - dv.y * dp.x;
    real up = rhs.x * dp.y - rhs.y * dp.x;
    if(down == 0)
        return -1;
    return up / down;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0xc0(%rbp)
addq $0x40, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4260
movq -0xc0(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x4240
movq -0xb8(%rbp), %rdi
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0xb0(%rbp)
addq $0x40, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4260
movq -0xb0(%rbp), %rdi
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x4240
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x4650
movq -0x28(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x5460
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x46d0
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x4650
movsd -0x50(%rbp), %xmm0
movsd -0x60(%rbp), %xmm2
movsd -0x48(%rbp), %xmm1
mulsd -0x68(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0xa0(%rbp)
movsd -0x98(%rbp), %xmm0
movsd -0x60(%rbp), %xmm2
movsd -0x90(%rbp), %xmm1
mulsd -0x68(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0xa8(%rbp)
movsd -0xa0(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x24c6
jp 0x24c6
movsd 0x10b51(%rip), %xmm0    # 0x13010
movsd %xmm0, -0x8(%rbp)
jmp 0x24db
movsd -0xa8(%rbp), %xmm0
divsd -0xa0(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: Mesh::fillTriangle(unsigned int, unsigned int, unsigned int, unsigned int)
void Mesh::fillTriangle(unsigned tIndex, unsigned eIndex0, unsigned eIndex1, unsigned eIndex2)
{
    Triangle &t = triangles[tIndex];
    t.eIndices[0] = eIndex0;
    t.eIndices[1] = eIndex1;
    t.eIndices[2] = eIndex2;

    connectEdges(eIndex0, eIndex1);
    connectEdges(eIndex1, eIndex2);
    connectEdges(eIndex2, eIndex0);
    halfEdges[eIndex0].tIndex = tIndex;
    halfEdges[eIndex1].tIndex = tIndex;
    halfEdges[eIndex2].tIndex = tIndex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4b60
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x2820
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2820
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2820
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
addq $0x40, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x4990
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rdi
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
addq $0x40, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4990
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rdi
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x40, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x4990
movl -0x24(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: Mesh::flipEdge(unsigned int)
void Mesh::flipEdge(unsigned eIndex)
{
    HalfEdge &e = halfEdges[eIndex];
    unsigned eIndexList[5];
    eIndexList[0] = e.nextIndex;
    eIndexList[1] = e.prevIndex;
    eIndexList[2] = e.neighborIndex;
    eIndexList[3] = halfEdges[e.neighborIndex].nextIndex;
    eIndexList[4] = halfEdges[e.neighborIndex].prevIndex;

    e.vIndices[0] = halfEdges[eIndexList[3]].vIndices[1];
    e.vIndices[1] = halfEdges[eIndexList[1]].vIndices[0];
    halfEdges[eIndexList[2]].vIndices[0] = e.vIndices[1];
    halfEdges[eIndexList[2]].vIndices[1] = e.vIndices[0];
    fillTriangle(e.tIndex, eIndex, eIndexList[1], eIndexList[3]);
    fillTriangle(halfEdges[e.neighborIndex].tIndex, eIndexList[2], eIndexList[4], eIndexList[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x40, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4990
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
addq $0x40, %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %esi
callq 0x4990
movq -0x38(%rbp), %rdi
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
addq $0x40, %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %esi
callq 0x4990
movq -0x38(%rbp), %rdi
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
addq $0x40, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x4990
movq -0x38(%rbp), %rdi
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x40, %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x4990
movq -0x38(%rbp), %rdi
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x40(%rbp)
addq $0x40, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x4990
movl -0x40(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
addq $0x40, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x4990
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl -0xc(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq 0x28e0
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %esi
callq 0x4990
movq -0x38(%rbp), %rdi
movl 0x8(%rax), %esi
movl -0x28(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x30(%rbp), %r8d
callq 0x28e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: Mesh::loadNodes(char const*)
std::vector<vec3> Mesh::loadNodes(const char* nodePath)
{
    glm::ivec4 h;
    std::vector<vec3> vList;
    FILE* file = fopen(nodePath, "r");
    if(fscanf(file, "%d %d %d %d", &h.x, &h.y, &h.z, &h.w) != 4)
    {
        fclose(file);
        return vList;
    }
    int nDims = h.y;
    glm::dvec4 v;
    while(1)
    {
        if(nDims == 2 && fscanf(file, "%d %lf %lf", &h.x, &v.x, &v.y) != 3)
            break;
        if(nDims == 3 && fscanf(file, "%d %lf %lf %lf", &h.x, &v.x, &v.y, &v.z) != 4)
            break;
        vList.push_back(vec3(v.x, v.y, 1));
    }
    fclose(file);
    return vList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5de0
movq -0xa0(%rbp), %rdi
movb $0x0, -0x29(%rbp)
callq 0x4110
movq -0x18(%rbp), %rdi
leaq 0xf708(%rip), %rsi      # 0x13054
callq 0x1140
movq %rax, -0x98(%rbp)
jmp 0x395a
movq -0x98(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x24(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x1c(%rbp), %r9
leaq 0xf6da(%rip), %rsi      # 0x13056
xorl %eax, %eax
leaq -0x28(%rbp), %rdx
callq 0x11d0
movl %eax, -0xac(%rbp)
jmp 0x398f
movl -0xac(%rbp), %eax
cmpl $0x4, %eax
je 0x39d2
movq -0x38(%rbp), %rdi
callq 0x1110
jmp 0x39a5
movb $0x1, -0x29(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x3ab4
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x42e0
jmp 0x3ad6
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5e10
jmp 0x39e3
jmp 0x39e5
jmp 0x39e7
cmpl $0x2, -0x4c(%rbp)
jne 0x3a20
movq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %r8
leaq 0xf666(%rip), %rsi      # 0x13062
xorl %eax, %eax
leaq -0x28(%rbp), %rdx
leaq -0x70(%rbp), %rcx
callq 0x11d0
movl %eax, -0xb0(%rbp)
jmp 0x3a13
movl -0xb0(%rbp), %eax
cmpl $0x3, %eax
je 0x3a20
jmp 0x3a9e
cmpl $0x3, -0x4c(%rbp)
jne 0x3a5d
movq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %r8
leaq -0x60(%rbp), %r9
leaq 0xf634(%rip), %rsi      # 0x1306d
xorl %eax, %eax
leaq -0x28(%rbp), %rdx
leaq -0x70(%rbp), %rcx
callq 0x11d0
movl %eax, -0xb4(%rbp)
jmp 0x3a50
movl -0xb4(%rbp), %eax
cmpl $0x4, %eax
je 0x3a5d
jmp 0x3a9e
leaq -0x68(%rbp), %rdx
movl $0x1, -0x8c(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x8c(%rbp), %rcx
callq 0x4750
jmp 0x3a84
movq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5e40
jmp 0x3a99
jmp 0x39e5
movq -0x38(%rbp), %rdi
callq 0x1110
jmp 0x3aa9
movb $0x1, -0x29(%rbp)
movl $0x1, -0x48(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x3ac6
movq -0xa0(%rbp), %rdi
callq 0x42e0
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x11c0
nop
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: Mesh::outputNodes(char const*)
void Mesh::outputNodes(const char* nodePath)
{
    glm::ivec4 h;
    std::vector<vec3> vList;
    FILE* file = fopen(nodePath, "w");
    fprintf(file, "%u 2 0 0\n", unsigned(vertices.size()));
    for(unsigned i=0; i<vertices.size(); i++)
    {
        vec3 &v = vertices[i].pos;
        fprintf(file, "%u %lf %lf\n", i+1, v.x, v.y);
    }
    fclose(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5de0
leaq -0x38(%rbp), %rdi
callq 0x4110
movq -0x10(%rbp), %rdi
leaq 0xf564(%rip), %rsi      # 0x1307c
callq 0x1140
movq %rax, -0x60(%rbp)
jmp 0x3b23
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x10, %rdi
callq 0x51b0
movq -0x70(%rbp), %rdi
movl %eax, %edx
leaq 0xf531(%rip), %rsi      # 0x1307e
movb $0x0, %al
callq 0x1160
movl $0x0, -0x50(%rbp)
movq -0x68(%rbp), %rdi
movl -0x50(%rbp), %eax
movq %rax, -0x78(%rbp)
addq $0x10, %rdi
callq 0x51b0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x3be0
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x51d0
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
movl -0x50(%rbp), %edx
addl $0x1, %edx
movq -0x58(%rbp), %rax
movsd (%rax), %xmm0
movq -0x58(%rbp), %rax
movsd 0x8(%rax), %xmm1
leaq 0xf4d1(%rip), %rsi      # 0x13088
movb $0x2, %al
callq 0x1160
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x3b5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x42e0
jmp 0x3bfd
movq -0x40(%rbp), %rdi
callq 0x1110
jmp 0x3beb
leaq -0x38(%rbp), %rdi
callq 0x42e0
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x11c0
nopw %cs:(%rax,%rax)
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: Mesh::outputElements(char const*)
void Mesh::outputElements(const char* elePath)
{
    glm::ivec4 h;
    std::vector<vec3> vList;
    FILE* file = fopen(elePath, "w");
    fprintf(file, "%u 3 0\n", unsigned(triangles.size()));
    for(unsigned i=0; i<triangles.size(); i++)
    {
        unsigned vi[3];
        for(unsigned k=0; k<3; k++)
            vi[k] = halfEdges[triangles[i].eIndices[k]].vIndices[0]+1;
        fprintf(file, "%u %u %u %u\n", i+1, vi[0], vi[1], vi[2]);
    }
    fclose(file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5de0
leaq -0x38(%rbp), %rdi
callq 0x4110
movq -0x10(%rbp), %rdi
leaq 0xf434(%rip), %rsi      # 0x1307c
callq 0x1140
movq %rax, -0x68(%rbp)
jmp 0x3c53
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x28, %rdi
callq 0x4a40
movq -0x78(%rbp), %rdi
movl %eax, %edx
leaq 0xf417(%rip), %rsi      # 0x13094
movb $0x0, %al
callq 0x1160
movl $0x0, -0x50(%rbp)
movq -0x70(%rbp), %rdi
movl -0x50(%rbp), %eax
movq %rax, -0x80(%rbp)
addq $0x28, %rdi
callq 0x4a40
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x3d4f
movl $0x0, -0x60(%rbp)
cmpl $0x3, -0x60(%rbp)
jae 0x3d1e
movq -0x70(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x88(%rbp)
addq $0x28, %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x4b60
movq -0x88(%rbp), %rdi
movl -0x60(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x4990
movl (%rax), %ecx
addl $0x1, %ecx
movl -0x60(%rbp), %eax
movl %ecx, -0x5c(%rbp,%rax,4)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x3cb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x42e0
jmp 0x3d6c
movq -0x40(%rbp), %rdi
movl -0x50(%rbp), %edx
addl $0x1, %edx
movl -0x5c(%rbp), %ecx
movl -0x58(%rbp), %r8d
movl -0x54(%rbp), %r9d
leaq 0xf362(%rip), %rsi      # 0x1309c
movb $0x0, %al
callq 0x1160
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x3c8b
movq -0x40(%rbp), %rdi
callq 0x1110
jmp 0x3d5a
leaq -0x38(%rbp), %rdi
callq 0x42e0
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x11c0
nopw %cs:(%rax,%rax)
// File: sunweilun[P]Delaunay/Mesh.cpp
// Function: randu(unsigned int&)
unsigned randu(unsigned& seed)
{
    unsigned m_z = seed >> 16;
    unsigned m_w = seed & 0xffff;
    m_z = 36969 * (m_z & 65535) + (m_z >> 16);
    m_w = 18000 * (m_w & 65535) + (m_w >> 16);
    seed = (m_z << 16) + m_w;
    return seed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x10, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
imull $0x9069, %eax, %eax     # imm = 0x9069
movl -0xc(%rbp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
imull $0x4650, %eax, %eax     # imm = 0x4650
movl -0x10(%rbp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
shll $0x10, %ecx
addl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
popq %rbp
retq
nopl (%rax,%rax)