LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::writeBinary(std::ostream&) const
void Datapoint::writeBinary(ostream &os) const {
    unsigned int s = size();
    os.write((const char *)&s, sizeof(unsigned int));
    Datapoint::const_iterator b = this->begin();
    os.write((const char *)&(*b), size() * sizeof(double));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x9b60
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x24(%rsp), %rsi
movl $0x4, %edx
callq 0x5500
movq (%rsp), %rdi
callq 0x9c70
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x9ca0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x9b60
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
shlq $0x3, %rdx
callq 0x5500
addq $0x38, %rsp
retq
nop
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::writeBinary(_IO_FILE*) const
void Datapoint::writeBinary(FILE *out) const {
    unsigned int s = size();
    fwrite((void *)&s, sizeof(unsigned int), 1, out);
    Datapoint::const_iterator b = this->begin();
    fwrite((void *)&(*b), sizeof(double), size(), out);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9b60
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rcx
leaq 0x24(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x5720
movq 0x8(%rsp), %rdi
callq 0x9c70
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x9ca0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x9b60
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movq 0x28(%rsp), %rcx
movl $0x8, %esi
callq 0x5720
addq $0x38, %rsp
retq
nop
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::readBinary(std::istream&)
void Datapoint::readBinary(istream &is) {
    unsigned int length;
    is.read((char *)&length, sizeof(unsigned int));
    resize(length);
    Datapoint::iterator b = this->begin();
    is.read((char *)&(*b), length * sizeof(double));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x24(%rsp), %rsi
movl $0x4, %edx
callq 0x54b0
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x9bd0
movq 0x8(%rsp), %rdi
callq 0x9cb0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x9ce0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movl 0x24(%rsp), %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x54b0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: Datapoint::readBinary(_IO_FILE*)
void Datapoint::readBinary(FILE *in) {
    unsigned int length;
    fread((void *)&length, sizeof(unsigned int), 1, in);
    resize(length);
    Datapoint::iterator b = this->begin();
    fread((void *)&(*b), sizeof(double), length, in);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
leaq 0x14(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x55b0
movq (%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x9bd0
movq (%rsp), %rdi
callq 0x9cb0
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x9ce0
movq %rax, %rdi
movl 0x14(%rsp), %eax
movl %eax, %edx
movq 0x18(%rsp), %rcx
movl $0x8, %esi
callq 0x55b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Datapoint.cpp
// Function: operator<<(std::ostream&, Datapoint const&)
ostream &operator<<(ostream &os, const Datapoint &dp) {
    unsigned int s = dp.size();
    for (unsigned int i = 0; i < s; i++) {
        os.precision(20);
        os << dp[i] << "\t";
    }
    return os;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9b60
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x9938
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x14, %esi
callq 0x9cf0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x5700
movq %rax, %rdi
leaq 0x298d8(%rip), %rsi     # 0x331fe
callq 0x5360
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x98d4
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::operator==(Dataset const&) const
bool Dataset::operator==(const Dataset &other) const {
    unsigned int nrows = numRows();
    unsigned int ncols = numCols();

    if (! (nrows == other.numRows() && ncols == other.numCols())) {
        return false;
    }

    for (unsigned int i = 0; i < nrows; i++) {
        for (unsigned int j = 0; j < ncols; j++) {
            if ((*this)[i][j] != other[i][j]) {
                return false;
            }
        }
    }

    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc0c0
movq 0x10(%rsp), %rdi
movl %eax, 0x2c(%rsp)
callq 0xc0d0
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc0c0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jne 0xb117
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc0d0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
je 0xb121
movb $0x0, 0x47(%rsp)
jmp 0xb1ca
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jae 0xb1c5
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x28(%rsp), %eax
jae 0xb1b3
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movsd (%rsp), %xmm0
ucomisd (%rax), %xmm0
jne 0xb19d
jp 0xb19d
jmp 0xb1a4
movb $0x0, 0x47(%rsp)
jmp 0xb1ca
jmp 0xb1a6
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xb13f
jmp 0xb1b5
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xb129
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::write(std::ostream&) const
void Dataset::write(ostream &os) const {
    bool hasWeights = weights.size() > 0;
    os.precision(20);

    unsigned int nr = numRows();
    os << nr << ":" << (hasWeights ? "w\n" : "\n");

    for (unsigned int row = 0; row < nr; row++) {
        if (hasWeights) { os << weights[row] << " "; }
        (*this)[row].write(os);
        os << endl;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
callq 0x9b60
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x14, %esi
callq 0x9cf0
movq 0x10(%rsp), %rdi
callq 0xc0c0
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x5520
movq %rax, %rdi
leaq 0x27fa3(%rip), %rsi     # 0x3325d
callq 0x5360
movq %rax, %rdi
movb 0x27(%rsp), %cl
leaq 0x28cf8(%rip), %rsi     # 0x33fc5
leaq 0x27f84(%rip), %rax     # 0x33258
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x5360
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jae 0xb376
testb $0x1, 0x27(%rsp)
je 0xb338
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x5700
movq %rax, %rdi
leaq 0x2ae71(%rip), %rsi     # 0x361a4
callq 0x5360
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x9310
movq 0x28(%rsp), %rdi
movq 0x38c5f(%rip), %rsi     # 0x43fc0
callq 0x53c0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xb2e8
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::write(_IO_FILE*) const
void Dataset::write(FILE *out) const {
    bool hasWeights = weights.size() > 0;
    unsigned int nr = numRows();

    fprintf(out, "%u:", nr);
    if (hasWeights) { fprintf(out, "w"); }
    fprintf(out, "\n");

    for (unsigned int row = 0; row < nr; row++) {
        if (hasWeights) { fprintf(out, "%.20f ", weights[row]); }
        (*this)[row].write(out);
        fprintf(out, "\n");
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
callq 0x9b60
movq 0x10(%rsp), %rdi
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movb %al, 0x27(%rsp)
callq 0xc0c0
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %edx
leaq 0x27e8f(%rip), %rsi     # 0x3325b
movb $0x0, %al
callq 0x5570
testb $0x1, 0x27(%rsp)
je 0xb3ed
movq 0x28(%rsp), %rdi
leaq 0x27e79(%rip), %rsi     # 0x3325f
movb $0x0, %al
callq 0x5570
movq 0x28(%rsp), %rdi
leaq 0x28bcc(%rip), %rsi     # 0x33fc5
movb $0x0, %al
callq 0x5570
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jae 0xb48e
testb $0x1, 0x27(%rsp)
je 0xb44e
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
leaq 0x27d83(%rip), %rsi     # 0x331ca
movb $0x1, %al
callq 0x5570
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x93b0
movq 0x28(%rsp), %rdi
leaq 0x28b4e(%rip), %rsi     # 0x33fc5
movb $0x0, %al
callq 0x5570
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xb408
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::read(std::istream&)
void Dataset::read(istream &is) {
    unsigned int length;
    is >> length;

    char c = is.get();
    Utilities::check(':' == c, "Dataset::read() missing : separator");

    resize(length);

    // check for weights (backwards compatibility)
    c = is.get();
    bool hasWeights = (c == 'w');
    double weight;
    if (! hasWeights) { is.putback(c); }

    for (unsigned int i = 0; i < length; i++) {
        if (hasWeights) {
            is >> weight;
            setWeight(i, weight);
        } else {
            setWeight(i, 1.0 / length);
        }
        (*this)[i].read(is);
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x94(%rsp), %rsi
callq 0x5070
movq 0x98(%rsp), %rdi
callq 0x5450
movb %al, 0x93(%rsp)
movb 0x93(%rsp), %al
subb $0x3a, %al
sete %al
movb %al, 0x1f(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x56a0
movq 0x20(%rsp), %rdx
leaq 0x27d49(%rip), %rsi     # 0x33261
leaq 0x70(%rsp), %rdi
callq 0x74e0
jmp 0xb524
movb 0x1f(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x70(%rsp), %rsi
callq 0x7480
jmp 0xb53a
leaq 0x70(%rsp), %rdi
callq 0x5788
leaq 0x6f(%rsp), %rdi
callq 0x53e0
movl 0x94(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8c90
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0xb6e0
jmp 0xb57d
leaq 0x40(%rsp), %rdi
callq 0x9bc0
movq 0x98(%rsp), %rdi
callq 0x5450
movb %al, 0x93(%rsp)
movsbl 0x93(%rsp), %eax
cmpl $0x77, %eax
sete %al
andb $0x1, %al
movb %al, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0xb621
movq 0x98(%rsp), %rdi
movsbl 0x93(%rsp), %esi
callq 0x56f0
jmp 0xb621
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb5f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5788
leaq 0x6f(%rsp), %rdi
callq 0x53e0
jmp 0xb6c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x9bc0
jmp 0xb6c7
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x94(%rsp), %eax
jae 0xb6bf
testb $0x1, 0x3f(%rsp)
je 0xb669
movq 0x98(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x52e0
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movsd 0x30(%rsp), %xmm0
callq 0xc150
jmp 0xb68f
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x94(%rsp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x27bca(%rip), %xmm0    # 0x33250
divsd %xmm1, %xmm0
callq 0xc150
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xc130
movq %rax, %rdi
movq 0x98(%rsp), %rsi
callq 0x9440
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xb629
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::read(_IO_FILE*)
void Dataset::read(FILE *in) {
    unsigned int length;
    fscanf(in, "%u", &length);

    char c = fgetc(in);
    Utilities::check(':' == c, "Dataset::read() missing : separator");

    resize(length);

    // check for weights (backwards compatibility)
    c = fgetc(in);
    bool hasWeights = (c == 'w');
    double weight;
    if (! hasWeights) { ungetc(c, in); }

    for (unsigned int i = 0; i < length; i++) {
        if (hasWeights) {
            fscanf(in, "%lf", &weight);
            setWeight(i, weight);
        } else {
            setWeight(i, 1.0 / length);
        }
        (*this)[i].read(in);
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x27aa4(%rip), %rsi     # 0x331f7
xorl %eax, %eax
leaq 0x94(%rsp), %rdx
callq 0x56e0
movq 0x98(%rsp), %rdi
callq 0x55f0
movb %al, 0x93(%rsp)
movb 0x93(%rsp), %al
subb $0x3a, %al
sete %al
movb %al, 0x1f(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x56a0
movq 0x20(%rsp), %rdx
leaq 0x27ac0(%rip), %rsi     # 0x33261
leaq 0x70(%rsp), %rdi
callq 0x74e0
jmp 0xb7ad
movb 0x1f(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x70(%rsp), %rsi
callq 0x7480
jmp 0xb7c3
leaq 0x70(%rsp), %rdi
callq 0x5788
leaq 0x6f(%rsp), %rdi
callq 0x53e0
movl 0x94(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8c90
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0xb6e0
jmp 0xb806
leaq 0x40(%rsp), %rdi
callq 0x9bc0
movq 0x98(%rsp), %rdi
callq 0x55f0
movb %al, 0x93(%rsp)
movsbl 0x93(%rsp), %eax
cmpl $0x77, %eax
sete %al
andb $0x1, %al
movb %al, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0xb8aa
movsbl 0x93(%rsp), %edi
movq 0x98(%rsp), %rsi
callq 0x5090
jmp 0xb8aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb87e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5788
leaq 0x6f(%rsp), %rdi
callq 0x53e0
jmp 0xb959
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x9bc0
jmp 0xb959
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x94(%rsp), %eax
jae 0xb951
testb $0x1, 0x3f(%rsp)
je 0xb8fb
movq 0x98(%rsp), %rdi
leaq 0x27921(%rip), %rsi     # 0x331fa
leaq 0x30(%rsp), %rdx
movb $0x0, %al
callq 0x56e0
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movsd 0x30(%rsp), %xmm0
callq 0xc150
jmp 0xb921
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x94(%rsp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x27938(%rip), %xmm0    # 0x33250
divsd %xmm1, %xmm0
callq 0xc150
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xc130
movq %rax, %rdi
movq 0x98(%rsp), %rsi
callq 0x9570
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xb8b2
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::writeBinary(std::ostream&) const
void Dataset::writeBinary(ostream &os) const {
    // write the header information... size and whether weights are included
    unsigned int length = numRows();
    os.write((char *)&length, sizeof(unsigned int));

    unsigned int hasWeights = weights.size() > 0;
    os.write((char *)&hasWeights, sizeof(unsigned int));

    // write out all the data & weights (if appropriate)
    for (unsigned int row = 0; row < length; row++) {
        if (hasWeights) { os.write((char *)&(weights[row]), sizeof(double)); }
        (*this)[row].writeBinary(os);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc0c0
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x24(%rsp), %rsi
movl $0x4, %edx
callq 0x5500
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x9b60
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x4, %edx
callq 0x5500
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0xba4a
cmpl $0x0, 0x20(%rsp)
je 0xba20
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x5500
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x96b0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xb9df
addq $0x38, %rsp
retq
nop
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::writeBinary(_IO_FILE*) const
void Dataset::writeBinary(FILE *out) const {
    // write the header information... size and whether weights are included
    unsigned int length = numRows();
    fwrite((void *)&length, sizeof(unsigned int), 1, out);

    unsigned int hasWeights = weights.size() > 0;
    fwrite((void *)&hasWeights, sizeof(unsigned int), 1, out);

    // write out all the data & weights (if appropriate)
    for (unsigned int row = 0; row < length; row++) {
        if (hasWeights) { fwrite((void *)&(weights[row]), sizeof(double), 1, out); }
        (*this)[row].writeBinary(out);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc0c0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rcx
leaq 0x14(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x5720
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x9b60
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x5720
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0xbb2b
cmpl $0x0, 0x10(%rsp)
je 0xbb02
movq (%rsp), %rdi
addq $0x18, %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0x9b80
movq %rax, %rdi
movq 0x18(%rsp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x5720
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x9730
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xbac7
addq $0x28, %rsp
retq
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::readBinary(std::istream&)
void Dataset::readBinary(istream &is) {
    unsigned int length;
    is.read((char *)&length, sizeof(unsigned int));

    unsigned int hasWeights;
    is.read((char *)&hasWeights, sizeof(unsigned int));

    resize(length);

    double weight;
    for (unsigned int i = 0; i < length; i++) {
        if (hasWeights) {
            is.read((char *)&weight, sizeof(double));
            setWeight(i, weight);
        } else {
            setWeight(i, 1.0 / length);
        }
        (*this)[i].readBinary(is);
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x64(%rsp), %rsi
movl $0x4, %edx
movq %rdx, 0x8(%rsp)
callq 0x54b0
movq 0x8(%rsp), %rdx
movq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x54b0
movl 0x64(%rsp), %eax
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x8c90
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0xb6e0
jmp 0xbba1
leaq 0x48(%rsp), %rdi
callq 0x9bc0
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x64(%rsp), %eax
jae 0xbc5c
cmpl $0x0, 0x60(%rsp)
je 0xbc0c
movq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x8, %edx
callq 0x54b0
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movsd 0x30(%rsp), %xmm0
callq 0xc150
jmp 0xbc2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x9bc0
jmp 0xbc61
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x64(%rsp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x2762a(%rip), %xmm0    # 0x33250
divsd %xmm1, %xmm0
callq 0xc150
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xc130
movq %rax, %rdi
movq 0x68(%rsp), %rsi
callq 0x97b0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xbbb3
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x5690
nopl (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: Dataset::readBinary(_IO_FILE*)
void Dataset::readBinary(FILE *in) {
    unsigned int length;
    fread((void *)&length, sizeof(unsigned int), 1, in);

    unsigned int hasWeights;
    fread((void *)&hasWeights, sizeof(unsigned int), 1, in);

    resize(length);

    double weight;
    for (unsigned int i = 0; i < length; i++) {
        if (hasWeights) {
            fread((void *)&weight, sizeof(double), 1, in);
            setWeight(i, weight);
        } else {
            setWeight(i, 1.0 / length);
        }
        (*this)[i].readBinary(in);
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rcx
leaq 0x64(%rsp), %rdi
movl $0x4, %esi
movq %rsi, (%rsp)
movl $0x1, %edx
movq %rdx, 0x8(%rsp)
callq 0x55b0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x60(%rsp), %rdi
callq 0x55b0
movl 0x64(%rsp), %eax
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x8c90
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0xb6e0
jmp 0xbcee
leaq 0x48(%rsp), %rdi
callq 0x9bc0
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x64(%rsp), %eax
jae 0xbdae
cmpl $0x0, 0x60(%rsp)
je 0xbd5e
movq 0x68(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x55b0
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movsd 0x30(%rsp), %xmm0
callq 0xc150
jmp 0xbd81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x9bc0
jmp 0xbdb3
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x64(%rsp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x274d8(%rip), %xmm0    # 0x33250
divsd %xmm1, %xmm0
callq 0xc150
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xc130
movq %rax, %rdi
movq 0x68(%rsp), %rsi
callq 0x9830
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xbd00
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x5690
nopl (%rax)
// File: hanhwi[P]SimPoint/analysiscode/Dataset.cpp
// Function: operator<<(std::ostream&, Dataset const&)
ostream &operator<<(ostream &os, const Dataset &ds) {
    unsigned int s = ds.size();
    for (unsigned int i = 0; i < s; i++) {
        os << ds[i] << endl;
    }

    return os;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc110
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0xbe31
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x98b0
movq %rax, %rdi
movq 0x381a1(%rip), %rsi     # 0x43fc0
callq 0x53c0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xbde4
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/FVParser.cpp
// Function: FVParser::FVParser(_IO_FILE*)
FVParser::FVParser(FILE *input_file) {
    Utilities::check(input_file != NULL, 
                     "FVParser::FVParser() input_file is NULL");
    input = input_file;
    lineNumber = 0;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
testq %rax, %rax
setne %al
movb %al, 0x17(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x56a0
movq 0x18(%rsp), %rdx
leaq 0x24a8a(%rip), %rsi     # 0x3329c
leaq 0x38(%rsp), %rdi
callq 0x74e0
jmp 0xe81e
movb 0x17(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x38(%rsp), %rsi
callq 0x7480
jmp 0xe834
leaq 0x38(%rsp), %rdi
callq 0x5788
leaq 0x37(%rsp), %rdi
callq 0x53e0
movq 0x8(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xe889
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5788
leaq 0x37(%rsp), %rdi
callq 0x53e0
movq 0x28(%rsp), %rdi
callq 0x5690
nopl (%rax)
// File: hanhwi[P]SimPoint/analysiscode/KMeans.cpp
// Function: KMeans::initializeRandomly(int, Dataset const&, Dataset*)
void KMeans::initializeRandomly(int randSeed, const Dataset &data,
        Dataset *centers) {
    Random rand(randSeed);

    for (unsigned int i = 0; i < centers->numRows(); i++) {
        int ndx = rand.randInt() % data.numRows();
        (*centers)[i] = data[ndx];
    }
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movl %edi, 0x154(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movslq 0x154(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x10cb0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x140(%rsp), %rdi
callq 0xc0c0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jae 0xf3a7
leaq 0x28(%rsp), %rdi
callq 0x10d10
movl %eax, 0xc(%rsp)
movq 0x148(%rsp), %rdi
callq 0xc0c0
movl %eax, %ecx
movl 0xc(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x20(%rsp)
movq 0x148(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0xc0f0
movq %rax, 0x10(%rsp)
movq 0x140(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0xc130
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xdd20
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xf318
addq $0x158, %rsp            # imm = 0x158
retq
nop
// File: hanhwi[P]SimPoint/analysiscode/KMeans.cpp
// Function: KMeans::findLabelsAndDists(Dataset const&, Dataset const&, std::vector<int, std::allocator<int>>*, Datapoint*)
void KMeans::findLabelsAndDists(const Dataset &data, const Dataset &centers,
                                vector<int> *labels, Datapoint *dists) {
    unsigned int n = data.numRows();
    unsigned int k = centers.numRows();
    for (unsigned int i = 0; i < n; i++) {
        (*labels)[i] = 0;
        double minDist = data[i].distSquared(centers[0]);

        for (unsigned int c = 1; c < k; c++) {
            double d = data[i].distSquared(centers[c]);
            if (d < minDist) {
                (*labels)[i] = c;
                minDist = d;
            }
        }
        if (dists) { (*dists)[i] = sqrt(minDist); }
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
callq 0xc0c0
movl %eax, 0x44(%rsp)
movq 0x58(%rsp), %rdi
callq 0xc0c0
movl %eax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jae 0x10355
movq 0x50(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x10dd0
movl $0x0, (%rax)
movq 0x60(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc0f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x8e30
movsd %xmm0, 0x30(%rsp)
movl $0x1, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x10312
movq 0x60(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xc0f0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x8e30
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10300
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x10dd0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x10302
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1027e
cmpq $0x0, 0x48(%rsp)
je 0x10343
movsd 0x30(%rsp), %xmm0
callq 0x52b0
movsd %xmm0, (%rsp)
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x9ba0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x10345
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1021c
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/KMeans.cpp
// Function: KMeans::findWeights(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>>*)
void KMeans::findWeights(const vector<int> &labels, vector<int> *weights) {
    unsigned int i;
    for (i = 0; i < weights->size(); i++) {
        (*weights)[i] = 0;
    }

    for (i = 0; i < labels.size(); i++) {
        (*weights)[labels[i]]++;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x10df0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x103b9
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x10dd0
movl $0x0, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x10376
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x10df0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1041c
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x10e10
movq 0x8(%rsp), %rdi
movslq (%rax), %rsi
callq 0x10dd0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x103c1
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/./Utilities.h
// Function: Random::Random(long)
Random(long seed = 0) {
            state = seed > 1 ? -seed : seed;
            // these are the initial values used by Numerical Recipes
            idum2 = 123456789;
            iy = 0;
        }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x1, -0x10(%rsp)
jle 0x10cda
xorl %eax, %eax
subq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
jmp 0x10ce4
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
movq %rcx, (%rax)
movq $0x75bcd15, 0x8(%rax)   # imm = 0x75BCD15
movq $0x0, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: hanhwi[P]SimPoint/analysiscode/Simpoint.cpp
// Function: Simpoint::isRegularFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Simpoint::isRegularFile(const string &filename) {
    struct stat info;
    if (stat(filename.c_str(), &info) != 0) {
        return false;
    }
    return S_ISREG(info.st_mode);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x5190
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0x5330
cmpl $0x0, %eax
je 0x12578
movb $0x0, 0xa7(%rsp)
jmp 0x12592
movl 0x20(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
sete %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Simpoint.cpp
// Function: Simpoint::openInputVectorFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
FILE *Simpoint::openInputVectorFile(const string &filename, bool isGzipped) {
    Utilities::check(isRegularFile(filename),
            "openInputVectorFile() not regular file: " + filename);
    FILE *input = NULL;
    if (isGzipped) {
        string command = "gzip -dc " + filename;
        input = popen(command.c_str(), "r");
    } else {
        input = fopen(filename.c_str(), "r");
    }
    Utilities::check(input != NULL, 
        "openInputVectorFile() could not open file " + filename);
    return input;
}

// Assembly:
subq $0xb8, %rsp
movb %sil, %al
movq %rdi, 0xb0(%rsp)
andb $0x1, %al
movb %al, 0xaf(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x12540
movb %al, 0x27(%rsp)
movq 0xb0(%rsp), %rdx
leaq 0x20dc5(%rip), %rsi     # 0x333b0
leaq 0x88(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x7880
movb 0x27(%rsp), %al
movq 0x28(%rsp), %rsi
movzbl %al, %edi
callq 0x7480
jmp 0x12610
leaq 0x88(%rsp), %rdi
callq 0x5788
movq $0x0, 0x70(%rsp)
testb $0x1, 0xaf(%rsp)
je 0x126cb
movq 0xb0(%rsp), %rdx
leaq 0x20d96(%rip), %rsi     # 0x333d9
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7880
movq 0x10(%rsp), %rdi
callq 0x5190
movq %rax, %rdi
leaq 0x20c8f(%rip), %rsi     # 0x332f5
callq 0x5140
movq %rax, 0x18(%rsp)
jmp 0x12672
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5788
jmp 0x126ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x5788
jmp 0x1275e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5788
jmp 0x1275e
movq 0xb0(%rsp), %rdi
callq 0x5190
movq %rax, %rdi
leaq 0x20c13(%rip), %rsi     # 0x332f5
callq 0x5440
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
testq %rax, %rax
setne %al
movb %al, 0x7(%rsp)
movq 0xb0(%rsp), %rdx
leaq 0x20cd9(%rip), %rsi     # 0x333e3
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7880
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rsi
movzbl %al, %edi
callq 0x7480
jmp 0x1272c
leaq 0x30(%rsp), %rdi
callq 0x5788
movq 0x70(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5788
movq 0x80(%rsp), %rdi
callq 0x5690
nopl (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Simpoint.cpp
// Function: Simpoint::parseCmdLineOptions(int, char**)
bool Simpoint::parseCmdLineOptions(int argc, char **argv) {
    Logger::log() << "Command-line: \"";
    for (int i = 0; i < argc; i++) {
        if (i > 0) { Logger::log() << ' '; }
        Logger::log() << argv[i];
    }
    Logger::log() << "\"\n";

    if (argc == 1) {
        options.usage(argv[0]);
        return false;
    }

    if (! options.parseOptions(argc, argv)) {
        return false;
    }

    Logger::log() << "Using these options (*** indicates user-specified option):\n";
    options.printOptionSettings(Logger::log());
    Logger::log() << "-------------------------------------------------------------\n";

    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
callq 0x7ba0
movq %rax, %rdi
leaq 0x19f77(%rip), %rsi     # 0x33fb4
callq 0x5360
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x1a099
cmpl $0x0, 0x14(%rsp)
jle 0x1a06f
xorl %edi, %edi
callq 0x7ba0
movq %rax, %rdi
movl $0x20, %esi
callq 0x5430
xorl %edi, %edi
callq 0x7ba0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5360
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1a04a
xorl %edi, %edi
callq 0x7ba0
movq %rax, %rdi
leaq 0x19f1a(%rip), %rsi     # 0x33fc4
callq 0x5360
cmpl $0x1, 0x24(%rsp)
jne 0x1a0d3
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x2a7e0
movb $0x0, 0x37(%rsp)
jmp 0x1a146
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x28d80
testb $0x1, %al
jne 0x1a0f5
movb $0x0, 0x37(%rsp)
jmp 0x1a146
xorl %edi, %edi
callq 0x7ba0
movq %rax, %rdi
leaq 0x19ec1(%rip), %rsi     # 0x33fc7
callq 0x5360
movq 0x8(%rsp), %rax
addq $0x58, %rax
movq %rax, (%rsp)
xorl %edi, %edi
callq 0x7ba0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2a850
xorl %edi, %edi
callq 0x7ba0
movq %rax, %rdi
leaq 0x19d7f(%rip), %rsi     # 0x33ebb
callq 0x5360
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/Simpoint.cpp
// Function: main
int main(int argc, char **argv) {
    Simpoint simpointAnalyzer;

    if (simpointAnalyzer.parseCmdLineOptions(argc, argv)) {
        // do everything else
        simpointAnalyzer.doClustering();
    }

    return 0;
}

// Assembly:
subq $0x3f8, %rsp            # imm = 0x3F8
movl $0x0, 0x3f4(%rsp)
movl %edi, 0x3f0(%rsp)
movq %rsi, 0x3e8(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1b1c0
movq 0x8(%rsp), %rdi
movl 0x3f0(%rsp), %esi
movq 0x3e8(%rsp), %rdx
callq 0x1a010
movb %al, 0x13(%rsp)
jmp 0x1a1af
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x1a1b9
jmp 0x1a1e1
leaq 0x20(%rsp), %rdi
callq 0x18810
jmp 0x1a1c5
jmp 0x1a1e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x19d90
jmp 0x1a205
movl $0x0, 0x3f4(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x19d90
movl 0x3f4(%rsp), %eax
addq $0x3f8, %rsp            # imm = 0x3F8
retq
movq 0x18(%rsp), %rdi
callq 0x5690
nop
// File: hanhwi[P]SimPoint/analysiscode/SimpointOptions.cpp
// Function: SimpointOptions::parseOptions(int, char**)
bool SimpointOptions::parseOptions(int argc, char **argv) {
    if (! cmdLineParser.parseCmdLine(argc, argv)) {
        Logger::log() << "Error in parsing command line options:\n"
             << cmdLineParser.getErrorMsg() << endl;
        return false;
    }

    Logger::setLoggingLevel(verboseLevel);

    // check that the user has specified options in a way that is sensible
    string errMessage;
    if (! validateOptions(&errMessage)) {
        Logger::log() << "Error in combination of command-line options:\n";
        Logger::log() << errMessage << endl;
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x2e8, %rdi            # imm = 0x2E8
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x5be0
testb $0x1, %al
jne 0x28e03
xorl %edi, %edi
callq 0x7ba0
movq %rax, %rdi
leaq 0xca1e(%rip), %rsi      # 0x357e4
callq 0x5360
movq -0x58(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x2e8, %rdi            # imm = 0x2E8
callq 0x2bfe0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x5320
movq %rax, %rdi
movq 0x1b1cb(%rip), %rsi     # 0x43fc0
callq 0x53c0
movb $0x0, -0x1(%rbp)
jmp 0x28ec6
movq -0x58(%rbp), %rax
movl 0x70(%rax), %edi
callq 0x2c000
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5540
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x28ee0
movb %al, -0x61(%rbp)
jmp 0x28e2e
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x28eb2
jmp 0x28e37
xorl %edi, %edi
callq 0x7ba0
movq %rax, -0x78(%rbp)
jmp 0x28e44
movq -0x78(%rbp), %rdi
leaq 0xc9bd(%rip), %rsi      # 0x3580c
callq 0x5360
jmp 0x28e56
xorl %edi, %edi
callq 0x7ba0
movq %rax, -0x80(%rbp)
jmp 0x28e63
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5320
movq %rax, -0x88(%rbp)
jmp 0x28e79
movq -0x88(%rbp), %rdi
movq 0x1b139(%rip), %rsi     # 0x43fc0
callq 0x53c0
jmp 0x28e8e
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x28ebd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5788
jmp 0x28ed4
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5788
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5690
nopl (%rax)
// File: hanhwi[P]SimPoint/analysiscode/SimpointOptions.cpp
// Function: SimpointOptions::printOptionSettings(std::ostream&) const
void SimpointOptions::printOptionSettings(ostream &os) const {
    for (unsigned int i = 0; i < cmdLineParser.getNumOptions(); i++) {
        const CmdLineOption *opt = cmdLineParser.getOption(i);
        if (opt->isSpecified()) {
            os << "*** ";
        } else {
            os << "    ";
        }
        os << opt->getPrettyValue() << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
addq $0x2e8, %rdi            # imm = 0x2E8
callq 0x2c040
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jae 0x2a949
movq -0x58(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
movl -0x14(%rbp), %esi
callq 0x2c060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2c020
testb $0x1, %al
jne 0x2a8bb
jmp 0x2a8cd
movq -0x10(%rbp), %rdi
leaq 0xb8d6(%rip), %rsi      # 0x3619c
callq 0x5360
jmp 0x2a8dd
movq -0x10(%rbp), %rdi
leaq 0xb8c9(%rip), %rsi      # 0x361a1
callq 0x5360
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2c150
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x5320
movq %rax, -0x68(%rbp)
jmp 0x2a909
movq -0x68(%rbp), %rdi
movq 0x196ac(%rip), %rsi     # 0x43fc0
callq 0x53c0
jmp 0x2a91b
leaq -0x40(%rbp), %rdi
callq 0x5788
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2a872
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5788
jmp 0x2a952
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5690
nopl (%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/SimpointOptions.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> split(const string &s, char c) {
    vector<string> parts;
    unsigned long start = 0, end;
    while (start < s.size()) {
        end = s.find(c, start);
        if (end == string::npos) {
            parts.push_back(s.substr(start));
            start = s.size();
        } else {
            parts.push_back(s.substr(start, end - start));
            start = end + 1;
        }
    }

    return parts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x2c260
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5270
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x2aaad
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x54f0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x2aa4e
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movq $-0x1, %rcx
callq 0x53a0
jmp 0x2a9f6
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x79e0
jmp 0x2aa08
leaq -0x48(%rbp), %rdi
callq 0x5788
movq -0x10(%rbp), %rdi
callq 0x5270
movq %rax, -0x20(%rbp)
jmp 0x2aaa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2aad0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5788
jmp 0x2aad0
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
leaq -0x78(%rbp), %rdi
callq 0x53a0
jmp 0x2aa68
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x79e0
jmp 0x2aa7a
leaq -0x78(%rbp), %rdi
callq 0x5788
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2aaa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5788
jmp 0x2aad0
jmp 0x2a997
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x2aac3
movq -0x88(%rbp), %rdi
callq 0x1ba40
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1ba40
movq -0x50(%rbp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: hanhwi[P]SimPoint/analysiscode/./CmdLineParser.h
// Function: CmdLineParser::addOption(CmdLineOption*)
void addOption(CmdLineOption *option) {
            Utilities::check(option != NULL,
                    "CmdLineParser::addOption(): option cannnot be NULL");
            Utilities::check(findOption(option->getName()) == NULL, 
                    "CmdLineParser::addOption(): option " + option->getName() +
                    " is already added");
            optionNameToNdxMap[option->getName()] = allOptions.size();
            allOptions.push_back(option);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
testq %rax, %rax
setne %al
movb %al, -0x91(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x56a0
movq -0x90(%rbp), %rdx
leaq 0xaf01(%rip), %rsi      # 0x3621d
leaq -0x30(%rbp), %rdi
callq 0x74e0
jmp 0x2b327
movb -0x91(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq -0x30(%rbp), %rsi
callq 0x7480
jmp 0x2b33e
leaq -0x30(%rbp), %rdi
callq 0x5788
leaq -0x31(%rbp), %rdi
callq 0x53e0
movq -0x10(%rbp), %rdi
callq 0x76e0
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x75d0
testq %rax, %rax
sete %al
movb %al, -0xa9(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76e0
movq %rax, %rdx
leaq 0xaec9(%rip), %rsi      # 0x36250
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x7880
movq -0xa8(%rbp), %rsi
leaq 0xaecc(%rip), %rdx      # 0x36274
leaq -0x68(%rbp), %rdi
callq 0x7830
jmp 0x2b3b3
movb -0xa9(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
leaq -0x68(%rbp), %rsi
callq 0x7480
jmp 0x2b3ca
leaq -0x68(%rbp), %rdi
callq 0x5788
leaq -0x88(%rbp), %rdi
callq 0x5788
movq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0x7a10
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movl %ecx, -0xb0(%rbp)
addq $0x20, %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76e0
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x1a240
movl -0xb0(%rbp), %ecx
movq -0xa0(%rbp), %rdi
movl %ecx, (%rax)
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x2c5a0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b46a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5788
leaq -0x31(%rbp), %rdi
callq 0x53e0
jmp 0x2b4a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b498
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5788
leaq -0x88(%rbp), %rdi
callq 0x5788
movq -0x40(%rbp), %rdi
callq 0x5690
nopl (%rax)