// File: j-faria[P]cpp-loadtxt/./src/loadtxt.hpp
// Function: loadtxt<double>::operator()()
vector<vector<T>> operator()()
    {
        if (_fname.empty()) {
            string msg = "loadtxt: filename is empty";
            throw invalid_argument(msg);
        }

        ifstream infile( _fname );

        if (infile.fail()) {
            string msg = "loadtxt: could not read file (" + _fname + ")!";
            throw runtime_error(msg);
        }
        
        // ignore first `skiprows` lines
        static const int max_line = 65536;
        for (size_t i = 0; i < _skiprows; i++)
            infile.ignore(max_line, '\n');

        vector<T> record;
        size_t rows_read = 0;

        // read each line
        while (rows_read < _max_rows || _max_rows == 0)
        {
            // clear the record before reading
            record.clear();

            // read the entire line into a string (a record is terminated by a newline)
            string line;
            getline(infile, line);

            if (infile.eof() && line.empty())
                break;
            
            if (line.find(_comments, 0) == 0)
                continue;

            // // use a stringstream to separate the fields out of the line
            // stringstream ss(line);

            size_t found = line.find_first_of(_delimiters);

            while (found != string::npos) {
                string cell = line.substr(0, found);

                if (!cell.empty()) {
                    // convert the field to a double
                    try
                    {
                        T val = convert(cell);
                        record.push_back(val);
                    }
                    catch(const std::invalid_argument& e)
                    {
                        std::cerr << "loadtxt: while reading file \"" << _fname << "\", ";
                        std::cerr << "could not convert field '" << cell << "' to double ";
                        std::cerr << "at row " << rows_read << " column " << record.size() + 1 << "\n";
                        throw;
                    }
                    
                }
                line.erase(0, found + 1);
                found = line.find_first_of(_delimiters);

                if (found == string::npos) {
                    if (line.empty())
                        continue;

                    try
                    {
                        T val = convert(line);
                        record.push_back(val);
                    }
                    catch(const std::invalid_argument& e)
                    {
                        std::cerr << "loadtxt: while reading file \"" << _fname << "\", ";
                        std::cerr << "could not convert field '" << line << "' to double ";
                        std::cerr << "at row " << rows_read << " column " << record.size() + 1 << "\n";
                        // throw;
                    }
                }
            }
            // // convert each field to a double
            // // and add the newly-converted field to the end of the record
            // string cell;
            // double f;

            // while (getline(ss, cell, _delimiters[0])) {
            //     if (cell.empty()) continue;
            //     f = stod(cell);   
            //     record.push_back(f);
            // }

            // while (ss >> f) {
            //         record.push_back(f);
            // }

            _filedata.push_back(record);

            rows_read++;
        }
        
        // complain if something went wrong
        if (rows_read != _max_rows && !infile.eof())
        {
            cout << "loadtxt: could not read file (" << _fname << ")!\n";
            exit(1);
        }

        infile.close();

        size_t nlines = _filedata.size();

        // only read _max_rows of content
        if (_max_rows != 0)
            nlines = min(nlines, _max_rows);

        size_t ncols = _filedata[0].size();

        vector<int> cols;
        if (_usecols.size() == 0)
        {
            data.resize(ncols);
            cols.resize(ncols);
            std::iota(cols.begin(), cols.end(), 0);
        }
        else
        {
            data.resize(_usecols.size());
            cols = _usecols;
            //! usecols starts from 1!
            for (auto& j : cols)
                j--;
        }

        for (size_t i = 0; i < data.size(); i++)
            data[i].reserve(nlines);
        
        for (size_t i = 0; i < nlines; i++)
        {
            int k = 0;
            for (auto j : cols)
            {
                data[k].push_back(_filedata[i][j]);
                k++;
            }
        }
        
        return data;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rdi, -0x3d0(%rbp)
movq %rdi, %rax
movq %rax, -0x3c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x3c0(%rbp)
addq $0x18, %rdi
callq 0x33a0
testb $0x1, %al
jne 0x50a1
jmp 0x5162
leaq -0x31(%rbp), %rdi
movq %rdi, -0x3d8(%rbp)
callq 0x33f0
movq -0x3d8(%rbp), %rdx
leaq 0x6499(%rip), %rsi      # 0xb558
leaq -0x30(%rbp), %rdi
callq 0x4e30
jmp 0x50ca
leaq -0x31(%rbp), %rdi
callq 0x32c0
movl $0x10, %edi
callq 0x3140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x3e0(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x33d0
jmp 0x50f5
movq -0x3e0(%rbp), %rdi
movq 0xaecd(%rip), %rsi      # 0xffd0
movq 0xaeb6(%rip), %rdx      # 0xffc0
callq 0x33b0
jmp 0x5de9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32c0
jmp 0x5dd8
movq -0x3e0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3200
jmp 0x5154
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x5dd8
movq -0x3c0(%rbp), %rsi
addq $0x18, %rsi
leaq -0x250(%rbp), %rdi
movl $0x8, %edx
callq 0x3360
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x3e1(%rbp)
jmp 0x519e
movb -0x3e1(%rbp), %al
testb $0x1, %al
jne 0x51ad
jmp 0x529e
movq -0x3c0(%rbp), %rdx
addq $0x18, %rdx
leaq 0x63b4(%rip), %rsi      # 0xb573
leaq -0x290(%rbp), %rdi
callq 0x6610
jmp 0x51cd
leaq 0x63be(%rip), %rdx      # 0xb592
leaq -0x270(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x65c0
jmp 0x51e9
leaq -0x290(%rbp), %rdi
callq 0x31a0
movl $0x10, %edi
callq 0x3140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x3f0(%rbp)
leaq -0x270(%rbp), %rsi
callq 0x3370
jmp 0x521a
movq -0x3f0(%rbp), %rdi
movq 0xadc8(%rip), %rsi      # 0xfff0
movq 0xad81(%rip), %rdx      # 0xffb0
callq 0x33b0
jmp 0x5de9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5dcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x31a0
jmp 0x5dcc
movq -0x3f0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3200
jmp 0x528d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x31a0
jmp 0x5dcc
movq $0x0, -0x298(%rbp)
movq -0x3c0(%rbp), %rcx
movq -0x298(%rbp), %rax
cmpq 0x78(%rcx), %rax
jae 0x52eb
leaq -0x250(%rbp), %rdi
movl $0x10000, %esi          # imm = 0x10000
movl $0xa, %edx
callq 0x31b0
jmp 0x52d5
jmp 0x52d7
movq -0x298(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x298(%rbp)
jmp 0x52a9
leaq -0x2b0(%rbp), %rdi
callq 0x6720
movq $0x0, -0x2b8(%rbp)
movq -0x3c0(%rbp), %rdx
movq -0x2b8(%rbp), %rcx
movb $0x1, %al
cmpq 0x98(%rdx), %rcx
movb %al, -0x3f1(%rbp)
jb 0x5339
movq -0x3c0(%rbp), %rax
cmpq $0x0, 0x98(%rax)
sete %al
movb %al, -0x3f1(%rbp)
movb -0x3f1(%rbp), %al
testb $0x1, %al
jne 0x5348
jmp 0x592b
leaq -0x2b0(%rbp), %rdi
callq 0x6740
leaq -0x2d8(%rbp), %rdi
movq %rdi, -0x400(%rbp)
callq 0x3310
movq -0x400(%rbp), %rsi
leaq -0x250(%rbp), %rdi
callq 0x3080
jmp 0x537c
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x3410
movb %al, -0x401(%rbp)
jmp 0x539c
movb -0x401(%rbp), %al
testb $0x1, %al
jne 0x53a8
jmp 0x53da
leaq -0x2d8(%rbp), %rdi
callq 0x33a0
testb $0x1, %al
jne 0x53ba
jmp 0x53da
movl $0x6, -0x2dc(%rbp)
jmp 0x58e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x591a
movq -0x3c0(%rbp), %rsi
addq $0x38, %rsi
leaq -0x2d8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3450
cmpq $0x0, %rax
jne 0x540a
movl $0x5, -0x2dc(%rbp)
jmp 0x58e4
movq -0x3c0(%rbp), %rsi
addq $0x58, %rsi
leaq -0x2d8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3260
movq %rax, -0x2e8(%rbp)
cmpq $-0x1, -0x2e8(%rbp)
je 0x58ac
movq -0x2e8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x308(%rbp), %rdi
leaq -0x2d8(%rbp), %rsi
callq 0x32a0
jmp 0x545a
leaq -0x308(%rbp), %rdi
callq 0x33a0
testb $0x1, %al
jne 0x5633
movq -0x3c0(%rbp), %rdi
leaq -0x308(%rbp), %rsi
callq 0x6760
movsd %xmm0, -0x410(%rbp)
jmp 0x548b
movsd -0x410(%rbp), %xmm0
movsd %xmm0, -0x310(%rbp)
leaq -0x2b0(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x6790
jmp 0x54b0
jmp 0x5631
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 0x589e
movq -0x40(%rbp), %rdi
callq 0x3100
movq %rax, -0x318(%rbp)
movq 0xab00(%rip), %rdi      # 0xffe8
leaq 0x60a6(%rip), %rsi      # 0xb595
callq 0x3270
movq %rax, -0x418(%rbp)
jmp 0x54fd
movq -0x418(%rbp), %rdi
movq -0x3c0(%rbp), %rsi
addq $0x18, %rsi
callq 0x3250
movq %rax, -0x420(%rbp)
jmp 0x551d
movq -0x420(%rbp), %rdi
leaq 0x6088(%rip), %rsi      # 0xb5b3
callq 0x3270
jmp 0x5532
movq 0xaaaf(%rip), %rdi      # 0xffe8
leaq 0x6077(%rip), %rsi      # 0xb5b7
callq 0x3270
movq %rax, -0x428(%rbp)
jmp 0x554e
movq -0x428(%rbp), %rdi
leaq -0x308(%rbp), %rsi
callq 0x3250
movq %rax, -0x430(%rbp)
jmp 0x556a
movq -0x430(%rbp), %rdi
leaq 0x6059(%rip), %rsi      # 0xb5d1
callq 0x3270
jmp 0x557f
movq 0xaa62(%rip), %rdi      # 0xffe8
leaq 0x6051(%rip), %rsi      # 0xb5de
callq 0x3270
movq %rax, -0x438(%rbp)
jmp 0x559b
movq -0x438(%rbp), %rdi
movq -0x2b8(%rbp), %rsi
callq 0x30b0
movq %rax, -0x440(%rbp)
jmp 0x55b7
movq -0x440(%rbp), %rdi
leaq 0x6021(%rip), %rsi      # 0xb5e6
callq 0x3270
movq %rax, -0x448(%rbp)
jmp 0x55d3
leaq -0x2b0(%rbp), %rdi
callq 0x5eb0
movq -0x448(%rbp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x30b0
movq %rax, -0x450(%rbp)
jmp 0x55fa
movq -0x450(%rbp), %rdi
leaq 0x5fe9(%rip), %rsi      # 0xb5f1
callq 0x3270
jmp 0x560f
callq 0x3330
jmp 0x5de9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3390
jmp 0x562c
jmp 0x589e
jmp 0x5633
movq -0x2e8(%rbp), %rdx
incq %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x2d8(%rbp), %rdi
callq 0x30a0
jmp 0x564f
movq -0x3c0(%rbp), %rsi
addq $0x58, %rsi
leaq -0x2d8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3260
movq %rax, -0x2e8(%rbp)
cmpq $-0x1, -0x2e8(%rbp)
jne 0x5872
leaq -0x2d8(%rbp), %rdi
callq 0x33a0
testb $0x1, %al
jne 0x5691
jmp 0x56b1
movl $0x7, -0x2dc(%rbp)
jmp 0x587c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x589e
movq -0x3c0(%rbp), %rdi
leaq -0x2d8(%rbp), %rsi
callq 0x6760
movsd %xmm0, -0x458(%rbp)
jmp 0x56ce
movsd -0x458(%rbp), %xmm0
movsd %xmm0, -0x320(%rbp)
leaq -0x2b0(%rbp), %rdi
leaq -0x320(%rbp), %rsi
callq 0x6790
jmp 0x56f3
jmp 0x585b
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 0x589e
movq -0x40(%rbp), %rdi
callq 0x3100
movq %rax, -0x328(%rbp)
movq 0xa8bd(%rip), %rdi      # 0xffe8
leaq 0x5e63(%rip), %rsi      # 0xb595
callq 0x3270
movq %rax, -0x460(%rbp)
jmp 0x5740
movq -0x460(%rbp), %rdi
movq -0x3c0(%rbp), %rsi
addq $0x18, %rsi
callq 0x3250
movq %rax, -0x468(%rbp)
jmp 0x5760
movq -0x468(%rbp), %rdi
leaq 0x5e45(%rip), %rsi      # 0xb5b3
callq 0x3270
jmp 0x5775
movq 0xa86c(%rip), %rdi      # 0xffe8
leaq 0x5e34(%rip), %rsi      # 0xb5b7
callq 0x3270
movq %rax, -0x470(%rbp)
jmp 0x5791
movq -0x470(%rbp), %rdi
leaq -0x2d8(%rbp), %rsi
callq 0x3250
movq %rax, -0x478(%rbp)
jmp 0x57ad
movq -0x478(%rbp), %rdi
leaq 0x5e16(%rip), %rsi      # 0xb5d1
callq 0x3270
jmp 0x57c2
movq 0xa81f(%rip), %rdi      # 0xffe8
leaq 0x5e0e(%rip), %rsi      # 0xb5de
callq 0x3270
movq %rax, -0x480(%rbp)
jmp 0x57de
movq -0x480(%rbp), %rdi
movq -0x2b8(%rbp), %rsi
callq 0x30b0
movq %rax, -0x488(%rbp)
jmp 0x57fa
movq -0x488(%rbp), %rdi
leaq 0x5dde(%rip), %rsi      # 0xb5e6
callq 0x3270
movq %rax, -0x490(%rbp)
jmp 0x5816
leaq -0x2b0(%rbp), %rdi
callq 0x5eb0
movq -0x490(%rbp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x30b0
movq %rax, -0x498(%rbp)
jmp 0x583d
movq -0x498(%rbp), %rdi
leaq 0x5da6(%rip), %rsi      # 0xb5f1
callq 0x3270
jmp 0x5852
callq 0x3390
jmp 0x5859
jmp 0x585b
jmp 0x5872
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3390
jmp 0x5870
jmp 0x589e
movl $0x0, -0x2dc(%rbp)
leaq -0x308(%rbp), %rdi
callq 0x31a0
movl -0x2dc(%rbp), %eax
testl %eax, %eax
je 0x5899
jmp 0x5894
jmp 0x542c
jmp 0x542c
leaq -0x308(%rbp), %rdi
callq 0x31a0
jmp 0x591a
movq -0x3c0(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x2b0(%rbp), %rsi
callq 0x6800
jmp 0x58c8
movq -0x2b8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2b8(%rbp)
movl $0x0, -0x2dc(%rbp)
leaq -0x2d8(%rbp), %rdi
callq 0x31a0
movl -0x2dc(%rbp), %eax
movl %eax, -0x49c(%rbp)
testl %eax, %eax
je 0x5915
jmp 0x5902
movl -0x49c(%rbp), %eax
subl $0x5, %eax
je 0x5302
jmp 0x5913
jmp 0x592b
jmp 0x5302
leaq -0x2d8(%rbp), %rdi
callq 0x31a0
jmp 0x5dc0
movq -0x3c0(%rbp), %rcx
movq -0x2b8(%rbp), %rax
cmpq 0x98(%rcx), %rax
je 0x59de
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x3410
movb %al, -0x49d(%rbp)
jmp 0x5966
movb -0x49d(%rbp), %al
testb $0x1, %al
jne 0x59de
jmp 0x5972
movq 0xa63f(%rip), %rdi      # 0xffb8
leaq 0x5bf3(%rip), %rsi      # 0xb573
callq 0x3270
movq %rax, -0x4a8(%rbp)
jmp 0x598e
movq -0x4a8(%rbp), %rdi
movq -0x3c0(%rbp), %rsi
addq $0x18, %rsi
callq 0x3250
movq %rax, -0x4b0(%rbp)
jmp 0x59ae
movq -0x4b0(%rbp), %rdi
leaq 0x5c33(%rip), %rsi      # 0xb5ef
callq 0x3270
jmp 0x59c3
movl $0x1, %edi
callq 0x32f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5dc0
leaq -0x250(%rbp), %rdi
callq 0x3090
jmp 0x59ec
movq -0x3c0(%rbp), %rdi
addq $0xa0, %rdi
callq 0x5e60
movq %rax, %rcx
movq -0x3c0(%rbp), %rax
movq %rcx, -0x330(%rbp)
cmpq $0x0, 0x98(%rax)
je 0x5a4e
movq -0x3c0(%rbp), %rsi
addq $0x98, %rsi
leaq -0x330(%rbp), %rdi
callq 0x6870
movq %rax, -0x4b8(%rbp)
jmp 0x5a3d
movq -0x4b8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x330(%rbp)
movq -0x3c0(%rbp), %rdi
addq $0xa0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5e90
movq %rax, %rdi
callq 0x5eb0
movq %rax, -0x338(%rbp)
leaq -0x350(%rbp), %rdi
callq 0x5f90
movq -0x3c0(%rbp), %rdi
addq $0x80, %rdi
callq 0x68b0
cmpq $0x0, %rax
jne 0x5b2d
movq -0x3c0(%rbp), %rdi
movq -0x338(%rbp), %rsi
callq 0x68d0
jmp 0x5ab2
movq -0x338(%rbp), %rsi
leaq -0x350(%rbp), %rdi
callq 0x6960
jmp 0x5ac7
leaq -0x350(%rbp), %rdi
movq %rdi, -0x4c0(%rbp)
callq 0x6a50
movq -0x4c0(%rbp), %rdi
movq %rax, -0x358(%rbp)
callq 0x6a80
movq %rax, -0x360(%rbp)
movq -0x358(%rbp), %rdi
movq -0x360(%rbp), %rsi
xorl %edx, %edx
callq 0x69f0
jmp 0x5b0b
jmp 0x5be5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x350(%rbp), %rdi
callq 0x6110
jmp 0x5dc0
movq -0x3c0(%rbp), %rdi
subq $-0x80, %rdi
callq 0x68b0
movq -0x3c0(%rbp), %rdi
movq %rax, %rsi
callq 0x68d0
jmp 0x5b4e
movq -0x3c0(%rbp), %rsi
subq $-0x80, %rsi
leaq -0x350(%rbp), %rdi
callq 0x6ab0
jmp 0x5b67
leaq -0x350(%rbp), %rax
movq %rax, -0x368(%rbp)
movq -0x368(%rbp), %rdi
callq 0x6a50
movq %rax, -0x370(%rbp)
movq -0x368(%rbp), %rdi
callq 0x6a80
movq %rax, -0x378(%rbp)
leaq -0x370(%rbp), %rdi
leaq -0x378(%rbp), %rsi
callq 0x6d00
testb $0x1, %al
jne 0x5bb4
jmp 0x5be3
leaq -0x370(%rbp), %rdi
callq 0x6d40
movq %rax, -0x380(%rbp)
movq -0x380(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
leaq -0x370(%rbp), %rdi
callq 0x6d60
jmp 0x5b9b
jmp 0x5be5
movq $0x0, -0x388(%rbp)
movq -0x3c0(%rbp), %rdi
movq -0x388(%rbp), %rax
movq %rax, -0x4c8(%rbp)
callq 0x5e60
movq %rax, %rcx
movq -0x4c8(%rbp), %rax
cmpq %rcx, %rax
jae 0x5c53
movq -0x3c0(%rbp), %rdi
movq -0x388(%rbp), %rsi
callq 0x5e90
movq %rax, %rdi
movq -0x330(%rbp), %rsi
callq 0x6d80
jmp 0x5c3d
jmp 0x5c3f
movq -0x388(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x388(%rbp)
jmp 0x5bf0
movq $0x0, -0x390(%rbp)
movq -0x390(%rbp), %rax
cmpq -0x330(%rbp), %rax
jae 0x5d6d
movl $0x0, -0x394(%rbp)
leaq -0x350(%rbp), %rax
movq %rax, -0x3a0(%rbp)
movq -0x3a0(%rbp), %rdi
callq 0x6a50
movq %rax, -0x3a8(%rbp)
movq -0x3a0(%rbp), %rdi
callq 0x6a80
movq %rax, -0x3b0(%rbp)
leaq -0x3a8(%rbp), %rdi
leaq -0x3b0(%rbp), %rsi
callq 0x6d00
testb $0x1, %al
jne 0x5ccc
jmp 0x5d54
leaq -0x3a8(%rbp), %rdi
callq 0x6d40
movq -0x3c0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x3b4(%rbp)
movslq -0x394(%rbp), %rsi
callq 0x5e90
movq -0x3c0(%rbp), %rdi
movq %rax, -0x4d0(%rbp)
addq $0xa0, %rdi
movq -0x390(%rbp), %rsi
callq 0x5e90
movq %rax, %rdi
movslq -0x3b4(%rbp), %rsi
callq 0x6e80
movq -0x4d0(%rbp), %rdi
movq %rax, %rsi
callq 0x6790
jmp 0x5d34
movl -0x394(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x394(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x6d60
jmp 0x5cb0
jmp 0x5d56
movq -0x390(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x390(%rbp)
jmp 0x5c5e
movq -0x3c0(%rbp), %rsi
movq -0x3d0(%rbp), %rdi
callq 0x6ea0
jmp 0x5d82
movl $0x1, -0x2dc(%rbp)
leaq -0x350(%rbp), %rdi
callq 0x6110
leaq -0x2b0(%rbp), %rdi
callq 0x6f90
leaq -0x250(%rbp), %rdi
callq 0x30c0
movq -0x3c8(%rbp), %rax
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
leaq -0x2b0(%rbp), %rdi
callq 0x6f90
leaq -0x250(%rbp), %rdi
callq 0x30c0
movq -0x40(%rbp), %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x61b0
nopl (%rax)