LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/hanhwi[P]SimPoint/analysiscode/./SimpointOptions.h
// Function: IntCmdLineOption::parseArgumentSub(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual bool parseArgumentSub(const string &argument) {
            int value = atoi(argument.c_str());
            if ((value < minValidValue) || (value > maxValidValue)) {
                setParseError("integer value is out of valid range of " 
                        + toString(minValidValue) + " to " 
                        + toString(maxValidValue));
                return false;
            }
            *intTarget = value;
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x4480
movl 0x9c(%r14), %esi
cmpl %esi, %eax
setge %cl
cmpl 0x98(%r14), %eax
setle %bl
andb %cl, %bl
je 0x12f9d
movq 0x90(%r14), %rcx
movl %eax, (%rcx)
jmp 0x1303d
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
callq 0x13a78
leaq 0x544f(%rip), %rsi      # 0x18402
leaq -0x58(%rbp), %rdi
movq %r15, %rdx
callq 0x11fc4
leaq 0x5464(%rip), %rdx      # 0x1842a
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5490
movl 0x98(%r14), %esi
leaq -0x38(%rbp), %rdi
callq 0x13a78
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5429
addq $0x68, %r14
leaq -0x98(%rbp), %rsi
movq %r14, %rdi
callq 0x41a0
leaq -0x98(%rbp), %rdi
callq 0x45e8
leaq -0x38(%rbp), %rdi
callq 0x45e8
leaq -0x78(%rbp), %rdi
callq 0x45e8
leaq -0x58(%rbp), %rdi
callq 0x45e8
leaq -0xb8(%rbp), %rdi
callq 0x45e8
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x45e8
jmp 0x13061
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x45e8
jmp 0x1306f
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x45e8
jmp 0x1307d
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x45e8
jmp 0x1308b
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x45e8
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/hanhwi[P]SimPoint/analysiscode/./SimpointOptions.h
// Function: DimensionCmdLineOption::parseArgumentSub(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual bool parseArgumentSub(const string &argument) {
            if (argument == string("noProject")) {
                *noProjectTarget = true;
                return true;
            }
            return IntCmdLineOption::parseArgumentSub(argument);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5348(%rip), %rsi      # 0x18474
leaq -0x48(%rbp), %r15
leaq -0x21(%rbp), %rdx
movq %r15, %rdi
callq 0x53a6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x130c1
movl %eax, %r12d
movq %r15, %rdi
callq 0x45e8
testb %r12b, %r12b
je 0x13165
movq 0xa0(%r14), %rax
movb $0x1, (%rax)
movb $0x1, %al
jmp 0x13170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12f5a
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hanhwi[P]SimPoint/analysiscode/./SimpointOptions.h
// Function: DimensionCmdLineOption::getPrettyValueSub[abi:cxx11]() const
virtual string getPrettyValueSub() const {
            string s;
            if (*noProjectTarget) { s = "noProject"; }
            else { s = toString(getIntValue()); }
            return s;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0xa0(%rsi), %rax
cmpb $0x1, (%rax)
jne 0x131b9
leaq 0x52c5(%rip), %rsi      # 0x18474
movq %rbx, %rdi
callq 0x4590
jmp 0x131e2
movq 0x90(%rsi), %rax
movl (%rax), %esi
leaq -0x30(%rbp), %rdi
callq 0x13a78
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4350
movq %r14, %rdi
callq 0x45e8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x131f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x45e8
movq %r14, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/hanhwi[P]SimPoint/analysiscode/./SimpointOptions.h
// Function: DoubleCmdLineOption::parseArgumentSub(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual bool parseArgumentSub(const string &argument) {
            double value = atof(argument.c_str());
            if ((value < minValidValue) || (value > maxValidValue)) {
                setParseError("double value is out of valid range of " 
                        + toString(minValidValue) + " to " 
                        + toString(maxValidValue));
                return false;
            }
            *doubleTarget = value;
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x4360
movapd %xmm0, %xmm1
movsd 0x98(%r14), %xmm0
movsd 0xa0(%r14), %xmm2
movapd %xmm1, %xmm3
cmpnltpd %xmm0, %xmm3
cmpnltpd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %ebx
testb $0x1, %bl
je 0x13282
movq 0x90(%r14), %rax
movsd %xmm1, (%rax)
jmp 0x13324
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
callq 0x13abb
leaq 0x5225(%rip), %rsi      # 0x184bd
leaq -0x58(%rbp), %rdi
movq %r15, %rdx
callq 0x11fc4
leaq 0x517f(%rip), %rdx      # 0x1842a
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5490
movsd 0xa0(%r14), %xmm0
leaq -0x38(%rbp), %rdi
callq 0x13abb
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5429
addq $0x68, %r14
leaq -0x98(%rbp), %rsi
movq %r14, %rdi
callq 0x41a0
leaq -0x98(%rbp), %rdi
callq 0x45e8
leaq -0x38(%rbp), %rdi
callq 0x45e8
leaq -0x78(%rbp), %rdi
callq 0x45e8
leaq -0x58(%rbp), %rdi
callq 0x45e8
leaq -0xb8(%rbp), %rdi
callq 0x45e8
andb $0x1, %bl
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x45e8
jmp 0x1334b
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x45e8
jmp 0x13359
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x45e8
jmp 0x13367
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x45e8
jmp 0x13375
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x45e8
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/hanhwi[P]SimPoint/analysiscode/Utilities.cpp
// Function: Utilities::sizeOfFVFile(FVParser&, int*, int*)
void Utilities::sizeOfFVFile(FVParser &parser, int *numPoints, 
                             int *numDims) {
    check(numPoints && numDims, 
          "Utilities::sizeOfFVFile() return values are null");

    *numPoints = 0;
    *numDims = 0;

    list<FVParserToken> tokens;
    while (parser.nextLine(&tokens)) {
        for (list<FVParserToken>::iterator i = tokens.begin(); i != tokens.end(); i++) {
            if (i->dimension > *numDims) {
                *numDims = i->dimension;
            }
        }
    }

    *numPoints = parser.currentLineNumber();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x4b20(%rip), %rsi      # 0x18637
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x53a6
testq %rbx, %rbx
setne %al
testq %r14, %r14
setne %cl
andb %al, %cl
movzbl %cl, %edi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x5364
movq %r12, %rdi
callq 0x45e8
andl $0x0, (%rbx)
andl $0x0, (%r14)
movq %r12, 0x10(%rsp)
movq %r12, 0x8(%rsp)
andq $0x0, 0x18(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x73fe
testb %al, %al
je 0x13b8a
movq %r12, %rax
movq (%rax), %rax
cmpq %r12, %rax
je 0x13b63
movl 0x10(%rax), %ecx
cmpl (%r14), %ecx
jle 0x13b75
movl %ecx, (%r14)
jmp 0x13b75
movl 0x8(%r15), %eax
movl %eax, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x7628
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x45e8
jmp 0x13bc7
movq %rax, %rbx
jmp 0x13bc7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7628
movq %rbx, %rdi
callq 0x4530
nop
// File: /workspace/github_cpp_makefile_star2_O2/hanhwi[P]SimPoint/analysiscode/Utilities.cpp
// Function: Utilities::randomProjectionMatrix(int, Dataset*)
void Utilities::randomProjectionMatrix(int randSeed, Dataset *projection) {
    check(NULL != projection, "Utilities::randomProjectionMatrix() projection is null");
    unsigned int rows = projection->size();
    check(rows > 0, "Utilities::randomProjectionMatrix() rows <= 0");
    unsigned int cols = (*projection)[0].size();
    check(cols > 0, "Utilities::randomProjectionMatrix() cols <= 0");

    Random rand(randSeed);

    for (unsigned int r = 0; r < rows; r++) {
        for (unsigned int c = 0; c < cols; c++) {
            (*projection)[r][c] = rand.randFloat() * 2.0 - 1.0;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x4a7b(%rip), %rsi      # 0x18668
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x53a6
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
leaq 0x10(%rsp), %rsi
callq 0x5364
leaq 0x10(%rsp), %rdi
callq 0x45e8
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
leaq 0x4a6d(%rip), %rsi      # 0x1869f
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x53a6
xorl %edi, %edi
testl %r14d, %r14d
setne %dil
leaq 0x10(%rsp), %rsi
callq 0x5364
leaq 0x10(%rsp), %rdi
callq 0x45e8
movq (%rbx), %rax
movq 0x8(%rax), %r12
subq (%rax), %r12
leaq 0x4a5e(%rip), %rsi      # 0x186cd
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x53a6
shrq $0x3, %r12
xorl %edi, %edi
testl %r12d, %r12d
setne %dil
leaq 0x10(%rsp), %rsi
callq 0x5364
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x45e8
movslq %ebp, %rax
movq %rax, %rcx
negq %rcx
cmpl $0x2, %eax
cmovlq %rax, %rcx
movq %rcx, (%r15)
movq $0x75bcd15, 0x8(%r15)   # imm = 0x75BCD15
andq $0x0, 0x10(%r15)
movl %r14d, %eax
movq %rax, 0x8(%rsp)
movl %r12d, %r12d
xorl %r13d, %r13d
cmpq 0x8(%rsp), %r13
je 0x13d12
imulq $0x18, %r13, %rbp
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x13d0d
movq %r15, %rdi
callq 0x13d46
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
addsd 0x16ad(%rip), %xmm0     # 0x153a8
movq (%rbx), %rax
movq (%rax,%rbp), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x13cde
incq %r13
jmp 0x13cd0
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13d2c
jmp 0x13d3b
jmp 0x13d2c
jmp 0x13d3b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x45e8
jmp 0x13d3e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4530
// File: /workspace/github_cpp_makefile_star2_O2/hanhwi[P]SimPoint/analysiscode/Utilities.cpp
// Function: Random::randFloat()
float Random::randFloat() {
    int j;
    long k;
    float temp;

    if (state <= 0) {
        if (-(state) < 1) state=1;
        else state = -(state);
        idum2=(state);
        for (j=NTAB+7;j>=0;j--) {
            k=(state)/IQ1;
            state=IA1*(state-k*IQ1)-k*IR1;
            if (state < 0) state += IM1;
            if (j < NTAB) iv[j] = state;
        }
        iy=iv[0];
    }
    k=(state)/IQ1;
    state=IA1*(state-k*IQ1)-k*IR1;
    if (state < 0) state += IM1;
    k=idum2/IQ2;
    idum2=IA2*(idum2-k*IQ2)-k*IR2;
    if (idum2 < 0) idum2 += IM2;
    j=iy/NDIV;
    iy=iv[j]-idum2;
    iv[j] = state;
    if (iy < 1) iy += IMM1;
    if ((temp=AM*iy) > RNMX) return RNMX;
    else return temp;
}

// Assembly:
movq (%rdi), %rsi
testq %rsi, %rsi
jle 0x13d58
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r8
jmp 0x13dc1
negq %rsi
pushq $0x1
popq %rcx
cmovbq %rsi, %rcx
pushq $0x27
popq %r8
movl $0xd1a4, %r9d           # imm = 0xD1A4
movq %rcx, %rsi
testl %r8d, %r8d
js 0x13db9
movq %rsi, %rax
cqto
idivq %r9
imulq $-0xd1a4, %rax, %rdx    # imm = 0xFFFF2E5C
addq %rsi, %rdx
imulq $0x9c4e, %rdx, %rdx     # imm = 0x9C4E
imulq $-0x2fb3, %rax, %rax    # imm = 0xD04D
leaq (%rdx,%rax), %rsi
addq $0x7fffffab, %rsi       # imm = 0x7FFFFFAB
addq %rax, %rdx
cmovnsq %rdx, %rsi
cmpl $0x1f, %r8d
ja 0x13db4
movl %r8d, %eax
movq %rsi, 0x18(%rdi,%rax,8)
decl %r8d
jmp 0x13d6f
movq 0x18(%rdi), %r8
movq %r8, 0x10(%rdi)
movl $0xd1a4, %r9d           # imm = 0xD1A4
movq %rsi, %rax
cqto
idivq %r9
imulq $-0xd1a4, %rax, %rdx    # imm = 0xFFFF2E5C
addq %rsi, %rdx
imulq $0x9c4e, %rdx, %rdx     # imm = 0x9C4E
imulq $-0x2fb3, %rax, %rax    # imm = 0xD04D
leaq (%rdx,%rax), %rsi
addq $0x7fffffab, %rsi       # imm = 0x7FFFFFAB
addq %rax, %rdx
cmovnsq %rdx, %rsi
movq %rsi, (%rdi)
movl $0xce26, %r9d           # imm = 0xCE26
movq %rcx, %rax
cqto
idivq %r9
imulq $-0xce26, %rax, %rdx    # imm = 0xFFFF31DA
addq %rcx, %rdx
imulq $0x9ef4, %rdx, %rcx     # imm = 0x9EF4
imulq $-0xecf, %rax, %rax     # imm = 0xF131
leaq (%rcx,%rax), %r9
addq $0x7fffff07, %r9        # imm = 0x7FFFFF07
addq %rax, %rcx
cmovnsq %rcx, %r9
movq %r9, 0x8(%rdi)
movl $0x3fffffe, %ecx        # imm = 0x3FFFFFE
movq %r8, %rax
cqto
idivq %rcx
cltq
movq 0x18(%rdi,%rax,8), %rcx
subq %r9, %rcx
movq %rcx, 0x10(%rdi)
movq %rsi, 0x18(%rdi,%rax,8)
movq 0x10(%rdi), %rax
testq %rax, %rax
jg 0x13e6b
addq $0x7fffffaa, %rax       # imm = 0x7FFFFFAA
movq %rax, 0x10(%rdi)
cvtsi2sd %rax, %xmm0
mulsd 0x47a8(%rip), %xmm0     # 0x18620
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm1
ucomisd 0x47a0(%rip), %xmm1     # 0x18628
jbe 0x13e92
movss 0x479e(%rip), %xmm0     # 0x18630
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Headers/Header.cpp
// Function: Header::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
size_t Header::parse(std::string content)
{
	size_t len = 0;
	size_t result = content.find("\r\n") + 2;

	while (content.find_first_not_of(" \t\v\f", result) != result)
		result = content.find("\r\n", result) + 2;
	_value = content.substr(1, result - 2);
	if (_value.find_first_not_of(" \t\v\f\r\n") > _value.find("\r\n") || _value.empty())
		throw std::invalid_argument("Bad line folding");
	_value.erase(_value.find_last_not_of(" \t\v\f\r\n") + 1);
	while ((len = _value.find("\r\n", len)) != std::string::npos)
		_value.erase(len, _value.find_first_not_of(" \t\v\f\r\n", len) - len);
	return (result);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x27077(%rip), %r12     # 0x2f880
leaq 0x23984(%rip), %r13     # 0x2c194
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7980
movq %rax, %rbp
leaq 0x2(%rax), %rbx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x7330
cmpq %rbx, %rax
jne 0x8810
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rcx
callq 0x7540
leaq 0x8(%r15), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x75f0
movq %r12, %rdi
callq 0x79b8
leaq 0x2392d(%rip), %rsi     # 0x2c199
movq %r14, %rdi
xorl %edx, %edx
callq 0x7330
movq %rax, %r12
leaq 0x27000(%rip), %rsi     # 0x2f880
movq %r14, %rdi
xorl %edx, %edx
callq 0x7980
cmpq %rax, %r12
ja 0x8916
cmpq $0x0, 0x10(%r15)
je 0x8916
leaq 0x238f8(%rip), %r15     # 0x2c199
pushq $-0x1
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x78b0
leaq 0x1(%rax), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x7120
xorl %r13d, %r13d
leaq 0x26fb4(%rip), %r12     # 0x2f880
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x7980
cmpq $-0x1, %rax
je 0x8904
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7330
subq %r13, %rax
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x7120
jmp 0x88cc
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x7290
movq %rax, %rbx
leaq 0x23878(%rip), %rsi     # 0x2c1a0
movq %rax, %rdi
callq 0x7910
movq 0x3a691(%rip), %rsi     # 0x42fc8
movq 0x3a672(%rip), %rdx     # 0x42fb0
movq %rbx, %rdi
callq 0x7830
movq %rax, %r14
movq %rbx, %rdi
callq 0x73d0
movq %r14, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Methods/DeleteMethod.cpp
// Function: DeleteMethod::process(Request const&, ConfigContext const&, ServerSocket const&)
Response DeleteMethod::process(const Request& request, const ConfigContext& config, const ServerSocket&)
{
	URL url(request._url._path);
	int base_depth = 0;
	std::string realPath = config.rootPath(url._path, base_depth);
	try
	{
		realPath = ft::simplify_path(realPath, true, base_depth);
	}
	catch (std::exception& e)
	{
		return Response(404, url._path);
	}
	Response response(200, url._path);
	try
	{
		std::string file_path = realPath;
		struct stat	file_stats;
		if (lstat(file_path.c_str(), &file_stats) == 0 && S_ISREG(file_stats.st_mode))
		{
			if (unlink(file_path.c_str()) == 0)
				response.setCode(204);
			else
				response.setCode(202);
		}
		else
			response.setCode(404);
	}
	catch (std::exception& e)
	{
		response.setCode(500);
	}
	return (response);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rcx, %r14
movq %rdi, %rbx
leaq 0xb8(%rdx), %rsi
leaq 0xe0(%rsp), %rdi
callq 0x1625a
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
leaq 0x168(%rsp), %r15
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21a22
movl 0xc(%rsp), %ecx
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x17b31
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %r14
movq %r14, %rsi
callq 0x75f0
movq %r14, %rdi
callq 0x79b8
movq %rbx, %rdi
movl $0xc8, %esi
movq %r15, %rdx
callq 0x2a080
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7690
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x7940
movl $0x194, %esi            # imm = 0x194
testl %eax, %eax
jne 0x9773
movl $0xf000, %eax           # imm = 0xF000
andl 0x68(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x9773
movq 0x30(%rsp), %rdi
callq 0x7270
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal 0xca(,%rcx,2), %esi
movq %rbx, %rdi
callq 0x2a818
leaq 0x30(%rsp), %rdi
callq 0x79b8
leaq 0x10(%rsp), %rdi
callq 0x79b8
leaq 0xe0(%rsp), %rdi
callq 0x169e4
movq %rbx, %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x79b8
jmp 0x97c4
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x97f3
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x2a818
callq 0x77f0
jmp 0x9785
movq %rax, %r14
jmp 0x97f3
movq %rax, %r14
callq 0x77f0
movq %rbx, %rdi
callq 0x29f10
jmp 0x9800
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x79b8
jmp 0x984d
movq %rax, %r14
cmpl $0x1, %edx
jne 0x9800
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
movl $0x194, %esi            # imm = 0x194
movq %r15, %rdx
callq 0x2a080
callq 0x77f0
jmp 0x9785
jmp 0x97fd
movq %rax, %r14
callq 0x77f0
jmp 0x9800
movq %rax, %rdi
callq 0x8f59
movq %rax, %r14
leaq 0xe0(%rsp), %rdi
callq 0x169e4
movq %r14, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Methods/GetMethod.cpp
// Function: compare_nocase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool compare_nocase(const std::string& first, const std::string& second)
{
	if (first == "./" || first == "../") 
		return (true);
	unsigned int i=0;
	while ( (i < first.length()) && (i < second.length()) )
	{
		if (tolower(first[i]) < tolower(second[i]))
			return true;
		else if (tolower(first[i]) > tolower(second[i]))
			return false;
		++i;
	}
	return (first.length() < second.length());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x22a30(%rip), %rsi     # 0x2c331
callq 0x91b7
movb $0x1, %bpl
testb %al, %al
jne 0x9973
leaq 0x22a1c(%rip), %rsi     # 0x2c330
movq %r14, %rdi
callq 0x91b7
testb %al, %al
jne 0x9973
movq (%r14), %r15
movq 0x8(%r14), %rax
movq (%rbx), %r13
movq 0x8(%rbx), %r12
cmpq %r12, %rax
movq %r12, %rbp
movq %rax, (%rsp)
cmovbq %rax, %rbp
xorl %ecx, %ecx
movl %ecx, %r14d
cmpq %r14, %rbp
jbe 0x996b
movsbl (%r15,%r14), %edi
callq 0x76c0
movl %eax, %ebx
movsbl (%r13,%r14), %edi
callq 0x76c0
leal 0x1(%r14), %ecx
cmpl %eax, %ebx
je 0x993e
setl %bpl
jmp 0x9973
cmpq %r12, (%rsp)
setb %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Methods/GetMethod.cpp
// Function: GetMethod::get_last_modified_format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string GetMethod::get_last_modified_format(const std::string& realPath, const std::string& format)
{
	struct stat st;
	if (lstat(realPath.c_str(), &st) < 0)
		return "-";
	std::ostringstream convert;
	struct tm	time;
	strptime(std::string(convert.str()).c_str(), "%s", &time);
	convert << st.st_mtime;
	strptime(std::string(convert.str()).c_str(), "%s", &time);
	char		buffer[1024];
	strftime(buffer, sizeof(buffer), format.c_str(), &time);
	convert.str("");
	return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x670, %rsp            # imm = 0x670
movq %rcx, %r15
movq %rdi, %rbx
movq (%rdx), %rdi
leaq 0x68(%rsp), %rsi
callq 0x7940
testl %eax, %eax
js 0x9cb1
leaq 0xf8(%rsp), %rdi
callq 0x7670
leaq 0x100(%rsp), %r14
leaq 0x270(%rsp), %rdi
movq %r14, %rsi
callq 0x7780
leaq 0x270(%rsp), %r12
movq (%r12), %rdi
leaq 0x22770(%rip), %rsi     # 0x2c359
leaq 0x30(%rsp), %rdx
callq 0x70a0
movq %r12, %rdi
callq 0x79b8
movq 0xc0(%rsp), %rsi
leaq 0xf8(%rsp), %rdi
callq 0x74f0
leaq 0x270(%rsp), %rdi
movq %r14, %rsi
callq 0x7780
leaq 0x270(%rsp), %r12
movq (%r12), %rdi
leaq 0x22726(%rip), %rsi     # 0x2c359
leaq 0x30(%rsp), %r13
movq %r13, %rdx
callq 0x70a0
movq %r12, %rdi
callq 0x79b8
movq (%r15), %rdx
leaq 0x270(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r13, %rcx
callq 0x7440
leaq 0x230e8(%rip), %rsi     # 0x2cd4f
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x8032
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x7720
leaq 0x10(%rsp), %rdi
callq 0x79b8
leaq 0x270(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x8032
leaq 0xf8(%rsp), %rdi
callq 0x7140
jmp 0x9cc8
leaq 0x22ef4(%rip), %rsi     # 0x2cbac
leaq 0x270(%rsp), %rdx
movq %rbx, %rdi
callq 0x8032
movq %rbx, %rax
addq $0x670, %rsp            # imm = 0x670
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x9cf3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x79b8
jmp 0x9cf6
jmp 0x9cf3
jmp 0x9cf3
jmp 0x9cf3
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x7140
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Methods/GetMethod.cpp
// Function: GetMethod::get_file_size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string GetMethod::get_file_size(const std::string& realPath)
{
	struct stat st;
	if (lstat(realPath.c_str(), &st) < 0)
		return "-";
	std::ostringstream convert;
	convert << st.st_size;
	return convert.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq (%rdx), %rdi
movq %rsp, %rsi
callq 0x7940
testl %eax, %eax
js 0x9d64
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq 0x7670
movq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x74f0
leaq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x7780
leaq 0x90(%rsp), %rdi
callq 0x7140
jmp 0x9d7b
leaq 0x22e41(%rip), %rsi     # 0x2cbac
leaq 0x90(%rsp), %rdx
movq %rbx, %rdi
callq 0x8032
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x7140
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Methods/GetMethod.cpp
// Function: GetMethod::process_cgi(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, URL const&, ConfigContext const&, ServerSocket const&, Request const&)
Response GetMethod::process_cgi(const std::string& realPath, const URL& url, const ConfigContext& config, const ServerSocket& socket, const Request& request)
{
	Response response(200, url._path);
	if (!request.getHeaderValue("Accept-Encoding").empty())
		response.setCompression(request._headers);
	try
	{
		CGI	cgi(request, config, socket, realPath);
		cgi.process(response);
	}
	catch(const CGI::CGIException &e)
	{
		Logger::print(e.what(), NULL, ERROR, NORMAL);
		response.setCode(e.code());
	}
	return (response);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %r9, %r14
movq %r8, %r12
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x88(%rcx), %rdx
movl $0xc8, %esi
callq 0x2a080
leaq 0x203aa(%rip), %rsi     # 0x2c055
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movq 0x1a0(%rsp), %r13
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r13, %rsi
callq 0x292c2
leaq 0x48(%rsp), %rdi
movq 0x8(%rdi), %rbp
callq 0x79b8
leaq 0x28(%rsp), %rdi
callq 0x79b8
testq %rbp, %rbp
je 0xbd00
leaq 0x140(%r13), %rsi
movq %rbx, %rdi
callq 0x2a838
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0xfd8c
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x11968
leaq 0x48(%rsp), %rdi
callq 0x11460
movq %rbx, %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbdfc
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x11460
jmp 0xbd5f
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xbdff
movq %r14, %rdi
callq 0x7220
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rax, %rsi
callq 0x8032
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
xorl %esi, %esi
callq 0xbe10
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movl %eax, %esi
callq 0x2a818
callq 0x77f0
jmp 0xbd2d
jmp 0xbdfc
jmp 0xbddb
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x79b8
jmp 0xbdde
movq %rax, %r14
callq 0x77f0
jmp 0xbdff
movq %rax, %rdi
callq 0x8f59
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x79b8
jmp 0xbdff
movq %rax, %r14
movq %rbx, %rdi
callq 0x29f10
movq %r14, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Methods/TraceMethod.cpp
// Function: TraceMethod::process(Request const&, ConfigContext const&, ServerSocket const&)
Response TraceMethod::process(const Request& request, const ConfigContext&, const ServerSocket&)
{
	const URL& url = request._url;
	Response response(200, url._path);
	response.addHeader("Content-Type", "message/http; charset=UTF-8");
	response.addHeader("Server", "Webserv");
	response.addDateHeader();
	response.setBody(request._raw);
	return response;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0xb8, %rdx
movl $0xc8, %esi
callq 0x2a080
leaq 0x1d987(%rip), %rsi     # 0x2c152
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
leaq 0x1e057(%rip), %rsi     # 0x2c838
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x8032
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2a124
leaq 0x8(%rsp), %rdi
callq 0x79b8
leaq 0x28(%rsp), %rdi
callq 0x79b8
leaq 0x1da2f(%rip), %rsi     # 0x2c24c
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
leaq 0x1e35d(%rip), %rsi     # 0x2cb90
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x8032
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2a124
leaq 0x8(%rsp), %rdi
callq 0x79b8
leaq 0x28(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x2a2f0
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a82e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0xe890
jmp 0xe89f
jmp 0xe8b0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x79b8
jmp 0xe8a2
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x79b8
jmp 0xe8b3
jmp 0xe8b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x29f10
movq %r14, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/ClientSocket.cpp
// Function: ClientSocket::ClientSocket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
ClientSocket::ClientSocket(const std::string &host, int port)
{
	if (!Socket::Create(false))
    {
		throw ClientSocketException("Could not create client socket.");
    }
	if (!Socket::Connect(host, port))
    {
		throw ClientSocketException("Could not Connect to host.");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf234
leaq 0x341a0(%rip), %rax     # 0x42a98
movq %rax, (%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf342
testb %al, %al
je 0xe925
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xf4d8
testb %al, %al
je 0xe970
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x1df2b(%rip), %rsi     # 0x2c862
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xeb50
xorl %ebp, %ebp
leaq 0x34161(%rip), %rsi     # 0x42ac0
leaq 0x220(%rip), %rdx       # 0xeb86
movq %r14, %rdi
callq 0x7830
jmp 0xe9b9
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %r14
leaq 0x1df00(%rip), %rsi     # 0x2c882
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xeb50
xorl %ebp, %ebp
leaq 0x34116(%rip), %rsi     # 0x42ac0
leaq 0x1d5(%rip), %rdx       # 0xeb86
movq %r14, %rdi
callq 0x7830
movq %rax, %r15
leaq 0x8(%rsp), %rdi
jmp 0xe9cd
jmp 0xe9d9
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x79b8
testb %bpl, %bpl
jne 0xe9dc
jmp 0xe9e9
movq %rax, %r15
movq %r14, %rdi
callq 0x73d0
jmp 0xe9e9
movq %rax, %r15
movq %rbx, %rdi
callq 0xf2bc
movq %r15, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/ServerSocket.cpp
// Function: ServerSocket::ServerSocket(int)
ServerSocket::ServerSocket(int port) : m_port(port)
{
	if (!Socket::Create(true))
		throw ServerSocketException("Counldn't create socket.");
	if (!Socket::Bind(this->m_port))
		throw ServerSocketException("Counldn't bind to port.");
	if (!Socket::Listen())
		throw ServerSocketException("Counldn't listen to socket.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0xf234
leaq 0x33f31(%rip), %rax     # 0x42b10
movq %rax, (%rbx)
movl %ebp, 0x3c(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
movb $0x0, 0x50(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf342
testb %al, %al
je 0xec2f
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0xf3b8
testb %al, %al
je 0xec7d
movq %rbx, %rdi
callq 0xf698
testb %al, %al
je 0xecc8
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %r15
leaq 0x1dcc9(%rip), %rsi     # 0x2c90a
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0xf1c2
xorl %ebp, %ebp
leaq 0x33ecf(%rip), %rsi     # 0x42b38
leaq 0x588(%rip), %rdx       # 0xf1f8
movq %r15, %rdi
callq 0x7830
jmp 0xed11
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %r15
leaq 0x1dc94(%rip), %rsi     # 0x2c923
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0xf1c2
xorl %ebp, %ebp
leaq 0x33e81(%rip), %rsi     # 0x42b38
leaq 0x53a(%rip), %rdx       # 0xf1f8
movq %r15, %rdi
callq 0x7830
jmp 0xed11
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %r15
leaq 0x1dc61(%rip), %rsi     # 0x2c93b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xf1c2
xorl %ebp, %ebp
leaq 0x33e36(%rip), %rsi     # 0x42b38
leaq 0x4ef(%rip), %rdx       # 0xf1f8
movq %r15, %rdi
callq 0x7830
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xed31
jmp 0xed3d
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0xed31
jmp 0xed3d
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x79b8
testb %bpl, %bpl
jne 0xed40
jmp 0xed4d
movq %rax, %r14
movq %r15, %rdi
callq 0x73d0
jmp 0xed4d
movq %rax, %r14
leaq 0x40(%rbx), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0xf2bc
movq %r14, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/ServerSocket.cpp
// Function: ServerSocket::ServerSocket(ServerSocket const&)
ServerSocket::ServerSocket(const ServerSocket &src) : m_port(src.m_port)
{
	if (!Socket::Create(true))
		throw ServerSocketException("Counldn't create socket.");
	if (!Socket::Bind(this->m_port))
		throw ServerSocketException("Counldn't bind to port.");
	if (!Socket::Listen())
		throw ServerSocketException("Counldn't listen to socket.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf234
leaq 0x33d8e(%rip), %rax     # 0x42b10
movq %rax, (%rbx)
movl 0x3c(%r14), %eax
movl %eax, 0x3c(%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
movb $0x0, 0x50(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf342
testb %al, %al
je 0xedd6
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0xf3b8
testb %al, %al
je 0xee24
movq %rbx, %rdi
callq 0xf698
testb %al, %al
je 0xee6f
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %r15
leaq 0x1db22(%rip), %rsi     # 0x2c90a
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0xf1c2
xorl %ebp, %ebp
leaq 0x33d28(%rip), %rsi     # 0x42b38
leaq 0x3e1(%rip), %rdx       # 0xf1f8
movq %r15, %rdi
callq 0x7830
jmp 0xeeb8
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %r15
leaq 0x1daed(%rip), %rsi     # 0x2c923
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0xf1c2
xorl %ebp, %ebp
leaq 0x33cda(%rip), %rsi     # 0x42b38
leaq 0x393(%rip), %rdx       # 0xf1f8
movq %r15, %rdi
callq 0x7830
jmp 0xeeb8
pushq $0x28
popq %rdi
callq 0x7290
movq %rax, %r15
leaq 0x1daba(%rip), %rsi     # 0x2c93b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xf1c2
xorl %ebp, %ebp
leaq 0x33c8f(%rip), %rsi     # 0x42b38
leaq 0x348(%rip), %rdx       # 0xf1f8
movq %r15, %rdi
callq 0x7830
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xeed8
jmp 0xeee4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0xeed8
jmp 0xeee4
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x79b8
testb %bpl, %bpl
jne 0xeee7
jmp 0xeef4
movq %rax, %r14
movq %r15, %rdi
callq 0x73d0
jmp 0xeef4
movq %rax, %r14
leaq 0x40(%rbx), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0xf2bc
movq %r14, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/ServerSocket.cpp
// Function: ServerSocket::setServerPort(int)
void					ServerSocket::setServerPort(int port)
{
	m_port = port;
	std::ostringstream	convert;
	convert << m_port;
	m_port_str = convert.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
movl %esi, 0x3c(%rdi)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x7670
movl 0x3c(%rbx), %esi
movq %r14, %rdi
callq 0x7840
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x7780
addq $0x40, %rbx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x75f0
movq %r14, %rdi
callq 0x79b8
leaq 0x20(%rsp), %rdi
callq 0x7140
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0xf184
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7140
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::operator=(Socket const&)
Socket &				Socket::operator=(Socket const &rhs)
{
	if (this != &rhs)
	{
		this->m_ipaddr = rhs.m_ipaddr;
		this->m_sockfd = rhs.m_sockfd;
		this->m_addr_in = rhs.m_addr_in;
	}
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xf336
movq %rsi, %r14
addq $0x8, %rsi
leaq 0x8(%rbx), %rdi
callq 0x7300
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movups 0x2c(%r14), %xmm0
movups %xmm0, 0x2c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Create(bool)
bool					Socket::Create(bool nonblocking)
{
	m_sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (!this->Success())
		return (false);
	int optval = 1;
	if (setsockopt(this->m_sockfd, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&optval), sizeof(optval)))
		return (false);
	if (nonblocking)
		return (fcntl(this->m_sockfd, F_SETFL, O_NONBLOCK) != -1);
	return (true);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x7150
movl %eax, 0x28(%rbx)
cmpl $-0x1, %eax
je 0xf3ab
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x7880
testl %eax, %eax
sete %r14b
andb %r14b, %bpl
cmpb $0x1, %bpl
jne 0xf3ab
movl 0x28(%rbx), %edi
pushq $0x4
popq %rsi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x7320
cmpl $-0x1, %eax
setne %r14b
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Bind(int)
bool					Socket::Bind(int const port)
{
	if (!this->Success())
		return (false);
	this->m_addr_in.sin_family = AF_INET;
	this->m_addr_in.sin_addr.s_addr = INADDR_ANY;
	this->m_addr_in.sin_port = htons(port);
	if (bind(this->m_sockfd, reinterpret_cast<sockaddr*>(&this->m_addr_in), sizeof(this->m_addr_in)) != 0)
		return (false);
	this->m_ipaddr = my_inet_ntoa(this->m_addr_in.sin_addr);
	return (true);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %edi
cmpl $-0x1, %edi
je 0xf3ef
movw $0x2, 0x2c(%rbx)
andl $0x0, 0x30(%rbx)
leaq 0x2c(%rbx), %rax
rolw $0x8, %si
movw %si, 0x2e(%rbx)
pushq $0x10
popq %rdx
movq %rax, %rsi
callq 0x70c0
testl %eax, %eax
je 0xf3f3
xorl %eax, %eax
jmp 0xf41c
movl 0x30(%rbx), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf424
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x75f0
movq %r14, %rdi
callq 0x79b8
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: my_inet_ntoa[abi:cxx11](in_addr)
static std::string		my_inet_ntoa(struct in_addr in)
{
	std::stringstream ss;
	unsigned char *bytes = reinterpret_cast<unsigned char *>(&in);
	ss << static_cast<int>(bytes[0]) << "." << static_cast<int>(bytes[1]) << "." << static_cast<int>(bytes[2]) << "." << static_cast<int>(bytes[3]);
	return (ss.str());
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x73a0
leaq 0x10(%rsp), %rdi
movzbl %bpl, %esi
callq 0x7840
leaq 0x20171(%rip), %rsi     # 0x2f5c0
movq %rax, %rdi
callq 0x7510
movl %ebp, %ecx
shrl $0x8, %ecx
movzbl %cl, %esi
movq %rax, %rdi
callq 0x7840
leaq 0x20152(%rip), %rsi     # 0x2f5c0
movq %rax, %rdi
callq 0x7510
movl %ebp, %ecx
shrl $0x10, %ecx
movzbl %cl, %esi
movq %rax, %rdi
callq 0x7840
leaq 0x20133(%rip), %rsi     # 0x2f5c0
movq %rax, %rdi
callq 0x7510
shrl $0x18, %ebp
movq %rax, %rdi
movl %ebp, %esi
callq 0x7840
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x7780
movq %rsp, %rdi
callq 0x73f0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x73f0
movq %rbx, %rdi
callq 0x7860
nop
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Accept(Socket&)
bool					Socket::Accept(Socket &connection)
{
	int	addr_length = sizeof(this->m_addr_in);
	connection.m_sockfd = accept(this->m_sockfd, reinterpret_cast<sockaddr *>(&this->m_addr_in), reinterpret_cast<socklen_t*>(&addr_length));
	if (connection.m_sockfd <= 0)
		return (false);
	connection.m_ipaddr = my_inet_ntoa(this->m_addr_in.sin_addr);
	return (true);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
movl 0x28(%rdi), %edi
leaq 0x2c(%r14), %rsi
callq 0x71b0
movl %eax, %ebp
movl %eax, 0x28(%rbx)
testl %eax, %eax
jle 0xf710
movl 0x30(%r14), %esi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xf424
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x75f0
movq %r14, %rdi
callq 0x79b8
testl %ebp, %ebp
setg %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Socket/Socket.cpp
// Function: Socket::Recieve(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
int						Socket::Recieve(std::string &str) const
{
	char	buff[MAX_RECIEVE + 1];

	str = "";
	ft::bzero(buff, MAX_RECIEVE + 1);
	int ret = recv(this->m_sockfd, buff, MAX_RECIEVE, 0);
	switch (ret)
	{
	case -1:
		return (Logger::print("Error in Socket::Recieve", 0, ERROR, NORMAL));
	case 0:
		return (0);
	default:
		str = buff;
		return (ret);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10030, %rsp          # imm = 0x10030
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1d5f6(%rip), %rsi     # 0x2cd4f
movq %rbx, %rdi
callq 0x7930
leaq 0x30(%rsp), %r15
movl $0xffff, %esi           # imm = 0xFFFF
movq %r15, %rdi
callq 0x17dfa
movl 0x28(%r14), %edi
movl $0xfffe, %edx           # imm = 0xFFFE
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x71c0
movq %rax, %r14
testl %r14d, %r14d
je 0xf7d9
cmpl $-0x1, %r14d
jne 0xf7cc
leaq 0x1d239(%rip), %rsi     # 0x2c9d4
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8032
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf802
movl %eax, %r14d
leaq 0x10(%rsp), %rdi
callq 0x79b8
jmp 0xf7d9
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x7930
movl %r14d, %eax
addq $0x10030, %rsp          # imm = 0x10030
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/CGI.cpp
// Function: CGI::ParseURI(Request const&, ConfigContext const&)
int	CGI::ParseURI(const Request& req, const ConfigContext& config)
{
	std::string	cgi_path = config.getParam("cgi_dir").front();

	m_env_Script_Name = find_first_file(req._url._path, config);
	if (m_env_Script_Name.empty())
		m_env_Script_Name = req._url._path; //return (404); (tester pass...)
	m_env_Path_Info = m_realPath.substr(m_realPath.find(m_env_Script_Name) + m_env_Script_Name.size());
	if (m_env_Path_Info.empty())
		m_env_Path_Info = "";
	else if (m_env_Path_Info[m_env_Path_Info.size() - 1] == '/')
		m_env_Path_Info.erase(m_env_Path_Info.size() - 1);
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1bb4a(%rip), %rsi     # 0x2c6c1
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8032
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2167a
movq (%rax), %rsi
addq $0x10, %rsi
leaq 0x28(%rsp), %rdi
callq 0x7690
leaq 0x8(%rsp), %rdi
callq 0x79b8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x114da
leaq 0x40(%rbx), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x75f0
movq %r12, %rdi
callq 0x79b8
cmpq $0x0, 0x48(%rbx)
jne 0x10bf3
addq $0xb8, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x7300
leaq 0xc0(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x7990
addq 0x48(%rbx), %rax
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rax, %rdx
callq 0x7540
leaq 0x60(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x75f0
movq %r15, %rdi
callq 0x79b8
movq 0x68(%rbx), %rsi
testq %rsi, %rsi
je 0x10c5d
movq (%r14), %rax
cmpb $0x2f, -0x1(%rax,%rsi)
jne 0x10c6c
decq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x7120
jmp 0x10c6c
leaq 0x1c0eb(%rip), %rsi     # 0x2cd4f
movq %r14, %rdi
callq 0x7930
leaq 0x28(%rsp), %rdi
callq 0x79b8
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x10c8d
jmp 0x10c8d
movq %rax, %rbx
jmp 0x10ca4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x10c9f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79b8
movq %rbx, %rdi
callq 0x7860
// File: /workspace/github_cpp_makefile_star2_O2/mbourand[P]webserv/srcs/Utils/CGI.cpp
// Function: CGI::VectorToArray()
void	CGI::VectorToArray(void)
{
	m_c_env = new char*[m_env.size() + 1];
	for (size_t i = 0; i < m_env.size(); i++)
	{
		m_c_env[i] = new char[m_env[i].length() + 1];
		ft::strncpy(m_c_env[i], m_env[i].c_str(), m_env[i].size() + 1);
	}
	m_c_env[m_env.size()] = NULL;
	m_c_args = new char*[m_args.size() + 1];
	for (size_t i = 0; i < m_args.size(); i++)
	{
		m_c_args[i] = new char[m_args[i].size() + 1];
		ft::strncpy(m_c_args[i], m_args[i].c_str(), m_args[i].size() + 1);
	}
	m_c_args[m_args.size()] = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x1fffffffffffffff, %r14 # imm = 0x1FFFFFFFFFFFFFFF
movq 0xf8(%rdi), %r13
movq 0x100(%rdi), %rbp
movq %rbp, %rax
subq %r13, %rax
sarq $0x5, %rax
leaq 0x1(%rax), %rcx
shrq $0x3d, %rcx
leaq 0x8(,%rax,8), %rax
xorl %r15d, %r15d
negq %rcx
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x7030
movq %rax, 0x118(%rbx)
pushq $0x1
popq %r12
subq %r13, %rbp
sarq $0x5, %rbp
cmpq %rbp, %r15
jae 0x118a3
movq (%r13,%r12,8), %rdi
incq %rdi
callq 0x7030
movq 0x118(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0xf8(%rbx), %rax
movq 0x118(%rbx), %rcx
movq (%rcx,%r15,8), %rdi
movq -0x8(%rax,%r12,8), %rsi
movq (%rax,%r12,8), %rdx
incq %rdx
callq 0x17db8
incq %r15
movq 0xf8(%rbx), %r13
movq 0x100(%rbx), %rbp
addq $0x4, %r12
jmp 0x11845
movq 0x118(%rbx), %rax
andq $0x0, (%rax,%rbp,8)
movq 0xe0(%rbx), %r12
movq 0xe8(%rbx), %r13
movq %r13, %rax
subq %r12, %rax
sarq $0x5, %rax
leaq 0x1(%rax), %rcx
cmpq %r14, %rcx
leaq 0x8(,%rax,8), %rax
pushq $-0x1
popq %rdi
cmovbeq %rax, %rdi
callq 0x7030
movq %rax, 0x110(%rbx)
pushq $0x1
popq %r14
xorl %r15d, %r15d
subq %r12, %r13
sarq $0x5, %r13
cmpq %r13, %r15
jae 0x1194d
movq (%r12,%r14,8), %rdi
incq %rdi
callq 0x7030
movq 0x110(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0xe0(%rbx), %rax
movq 0x110(%rbx), %rcx
movq (%rcx,%r15,8), %rdi
movq -0x8(%rax,%r14,8), %rsi
movq (%rax,%r14,8), %rdx
incq %rdx
callq 0x17db8
incq %r15
movq 0xe0(%rbx), %r12
movq 0xe8(%rbx), %r13
addq $0x4, %r14
jmp 0x118f0
movq 0x110(%rbx), %rax
andq $0x0, (%rax,%r13,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq