LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::ToString[abi:cxx11]()
std::string Species::ToString() {
  std::ostringstream oss;
  oss << "immigrationTime: " << m_immigrationTime << std::endl;
  oss << "incoming:" << std::endl;
  for( auto pair : m_incomingInteractions ) {
    oss << "  " << pair.first << ", " << pair.second << std::endl;
  }
  return oss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2210
leaq 0x2ad9(%rip), %rsi      # 0x505c
movq %rbx, %rdi
callq 0x21a0
movl (%r14), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20b0
leaq 0x2ac9(%rip), %rsi      # 0x506e
leaq 0x10(%rsp), %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20b0
movq %r15, (%rsp)
movq 0x20(%r14), %r12
addq $0x10, %r14
leaq 0x2aae(%rip), %r15      # 0x5078
leaq 0x10(%rsp), %r13
leaq 0x2aa5(%rip), %rbp      # 0x507b
cmpq %r14, %r12
je 0x2631
movq 0x20(%r12), %rbx
movsd 0x28(%r12), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21a0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2280
movq %rax, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x2120
movq %rax, %r12
jmp 0x25d6
leaq 0x18(%rsp), %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x2270
leaq 0x10(%rsp), %rdi
callq 0x2050
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2663
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::LocalCC() const
double Species::LocalCC() const {
  SpeciesSet neighbors = m_outgoingInteractions;
  for( auto pair : m_incomingInteractions ) {
    neighbors.insert( pair.first );
  }
  size_t k = neighbors.size();
  if( k <= 1 ) { return 0.0; }

  std::vector<uint32_t> neighbor_ids;
  for( auto n: neighbors ) {
    n->MakeOutLinkCache();
    neighbor_ids.push_back( n->m_immigrationTime );
  }

  std::vector<uint32_t> vIntersec;
  for( auto pSpecies : neighbors ) {
    std::set_intersection( neighbor_ids.begin(), neighbor_ids.end(),
        pSpecies->m_outLinkCache.begin(), pSpecies->m_outLinkCache.end(),
        std::back_inserter( vIntersec ) );
  }
  size_t num_triads = vIntersec.size();

  return ( static_cast<double>(num_triads) / (k*(k-1)) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %rsi
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x3806
movq 0x20(%rbx), %r12
addq $0x10, %rbx
movq %rsp, %r15
cmpq %rbx, %r12
je 0x26d0
movupd 0x20(%r12), %xmm0
movapd %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x454e
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
jmp 0x26a7
movq 0x78(%rsp), %r12
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
cmpq $0x2, %r12
jb 0x27e3
movq %rsp, %rbx
andq $0x0, 0x10(%rbx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rbx)
leaq 0x58(%rsp), %r13
movq 0x10(%r13), %r14
cmpq %r13, %r14
je 0x272b
movq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x2834
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3612
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
jmp 0x2702
xorpd %xmm0, %xmm0
leaq 0x30(%rsp), %rbx
movapd %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq 0x68(%rsp), %r14
cmpq %r13, %r14
je 0x2771
movq 0x20(%r14), %rax
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x70(%rax), %rdx
movq 0x78(%rax), %rcx
movq %rbx, %r8
callq 0x4729
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
jmp 0x2742
leaq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x2, %rax
movq %rax, %xmm0
movq 0x28a2(%rip), %xmm1     # 0x5030
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x28a6(%rip), %xmm2     # 0x5040
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
leaq -0x1(%r12), %rax
imulq %r12, %rax
movq %rax, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
movapd %xmm3, 0x20(%rsp)
callq 0x4020
movq %rsp, %rdi
callq 0x4020
leaq 0x50(%rsp), %rdi
callq 0x3a3c
movaps 0x20(%rsp), %xmm0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4020
jmp 0x2815
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4020
jmp 0x2822
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3a3c
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::MakeOutLinkCache()
void Species::MakeOutLinkCache() {
  if( m_cacheReady == false ) {
    m_outLinkCache.clear();
    for( auto s: m_outgoingInteractions ) {
      uint32_t t = s->m_immigrationTime;
      m_outLinkCache.push_back(t);
    }
    m_cacheReady = true;
  }
}

// Assembly:
cmpb $0x0, 0x88(%rdi)
je 0x283e
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq %rax, 0x78(%rdi)
je 0x285c
movq %rax, 0x78(%rbx)
leaq 0x70(%rbx), %r14
movq 0x50(%rbx), %r12
leaq 0x40(%rbx), %r13
leaq 0xc(%rsp), %r15
cmpq %r13, %r12
je 0x2895
movq 0x20(%r12), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3612
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
jmp 0x286d
movb $0x1, 0x88(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::Update()
void DynamicalGraph::Update() {
  int previous_diversity = Diversity();

  AddOneSpecies();
  Selection();

  int current_diversity = Diversity();
  int extinction_size = previous_diversity + 1 - current_diversity;

  // calculate histograms
  extinction_histo.Add( extinction_size );

  diversity_histo.Add( current_diversity );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x30(%rdi), %ebp
callq 0x2dba
movq %rbx, %rdi
callq 0x2e0a
movl 0x30(%rbx), %r14d
subl %r14d, %ebp
incl %ebp
leaq 0x78(%rbx), %rdi
movl %ebp, %esi
callq 0x365a
addq $0xa8, %rbx
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x365a
nop
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::Selection()
void DynamicalGraph::Selection() {
  bool bNegativeExists = true;
  while(bNegativeExists) {
    bNegativeExists = RemoveNegativeFitnessSpecies();
  }

  m_dyingSpecies.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x2f5e
testb %al, %al
jne 0x2e0e
addq $0x38, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x4452
nop
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::AddRandomInteractions(Species*)
void DynamicalGraph::AddRandomInteractions(Species* s) {
  std::uniform_real_distribution<double> uniform(0.0,1.0);
  std::normal_distribution<double> nd;

  for( auto pSpecies : m_species ) {
    if( uniform(*pRnd) < m_connectance ) {
      s->MakeInteractionWith( pSpecies, nd(*pRnd) );
    }
    if( uniform(*pRnd) < m_connectance ) {
      pSpecies->MakeInteractionWith( s, nd(*pRnd) );
      if( pSpecies->IsGoingExtinct() ) { m_dyingSpecies.insert(pSpecies); }
    }
  }

  if( s->IsGoingExtinct() ) { m_dyingSpecies.insert(s); }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x18(%rsp)
xorpd %xmm0, %xmm0
movhpd 0x21c3(%rip), %xmm0     # xmm0 = xmm0[0],mem[0]
leaq 0x20(%rsp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x40(%rsp), %r13
movapd %xmm0, (%r13)
movb $0x0, 0x18(%rax)
movq 0x20(%rdi), %rbp
leaq 0x10(%rdi), %r12
leaq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
cmpq %r12, %rbp
je 0x2f2d
movq 0x20(%rbp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%r14), %rsi
movq %r13, %rdi
callq 0x36e4
movsd (%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2ec2
movq 0x8(%rsp), %r15
movq 0x70(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x36ec
movq %rbx, %rdi
movq %r15, %rsi
callq 0x23fc
movq 0x70(%r14), %rsi
movq %r13, %rdi
callq 0x36e4
movsd (%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2f1d
movq 0x8(%rsp), %r15
movq 0x70(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x36ec
movq %r15, %rdi
movq %rbx, %rsi
callq 0x23fc
movq 0x8(%rsp), %rax
xorpd %xmm0, %xmm0
ucomisd 0x68(%rax), %xmm0
jbe 0x2f1d
cmpq $0x0, 0x30(%rax)
je 0x2f1d
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x454e
movq %rbp, %rdi
callq 0x21e0
movq %rax, %rbp
jmp 0x2e7b
xorpd %xmm0, %xmm0
ucomisd 0x68(%rbx), %xmm0
jbe 0x2f4e
cmpq $0x0, 0x30(%rbx)
je 0x2f4e
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x454e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::RemoveNegativeFitnessSpecies()
bool DynamicalGraph::RemoveNegativeFitnessSpecies() {
  // remove negative fitness species
  // Find minimum
  Species* pMinSpecies = NULL;
  double min = 0.0;
  for( auto pSpecies : m_dyingSpecies ) {
    double f = pSpecies->Fitness();
    if( min > f ) {
      min = f;
      pMinSpecies = pSpecies;
    }
  }
  if( pMinSpecies != NULL ) {
    Extinct(pMinSpecies);
  }
  return (pMinSpecies != NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x50(%rdi), %rax
leaq 0x40(%rdi), %r15
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
cmpq %r15, %rax
je 0x2fa8
movq 0x20(%rax), %rcx
movsd 0x68(%rcx), %xmm1
ucomisd %xmm1, %xmm0
minsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
cmovaq %rcx, %rbx
movq %rax, %rdi
callq 0x21e0
movsd 0x8(%rsp), %xmm0
jmp 0x2f78
testq %rbx, %rbx
je 0x2fb8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fc8
testq %rbx, %rbx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::Extinct(Species*)
void DynamicalGraph::Extinct(Species* s) {
  s->DeleteInteractions(m_dyingSpecies);
  m_species.erase(s);

  int32_t lifetime = m_currentTime - s->ImmigrationTime();

  lifetime_histo.Add( lifetime );
  m_dyingSpecies.erase(s);

  delete s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
leaq 0x38(%rdi), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2460
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x42ea
movl 0x68(%rbx), %esi
movq (%r14), %rax
subl (%rax), %esi
addq $0xd8, %rbx
movq %rbx, %rdi
callq 0x365a
movq %r15, %rdi
movq %r14, %rsi
callq 0x42ea
movq (%r14), %rbx
testq %rbx, %rbx
je 0x3029
movq %rbx, %rdi
callq 0x36f4
movq %rbx, %rdi
callq 0x2190
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::AverageDiversity() const
double DynamicalGraph::AverageDiversity() const {
  uint64_t sum = 0;
  uint64_t count = 0;
  for( auto key_freq : diversity_histo.histo ) {
    sum += key_freq.first * key_freq.second;
    count += key_freq.second;
  }
  return static_cast<double>(sum)/count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
addq $0xb0, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %rbx, %rax
je 0x319e
movl 0x24(%rax), %ecx
movl 0x20(%rax), %edx
imull %ecx, %edx
addq %rdx, %r15
addq %rcx, %r14
movq %rax, %rdi
callq 0x21e0
jmp 0x3180
movq %r15, %xmm1
movq 0x1e85(%rip), %xmm2     # 0x5030
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1e89(%rip), %xmm3     # 0x5040
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %r14, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Histogram::Add(unsigned int)
void Add( uint32_t x ) {
    if( histo.find(x) != histo.end() ) {
      histo[x] += 1;
    }
    else {
      histo[x] = 1;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %esi, (%r14)
movq %r14, %rsi
callq 0x3b14
movq %rax, %r15
leaq 0x8(%rbx), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ac6
movl (%rax), %ecx
incl %ecx
cmpq %r12, %r15
pushq $0x1
popq %rdx
cmovnel %ecx, %edx
movl %edx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/noizebox[P]zipfsong/zipfsong_cpp_fast.cpp
// Function: parse_songs(int, std::vector<Song, std::allocator<Song>>&, char*, unsigned long)
void parse_songs(const int songs, std::vector<Song>& song_list, char* mem, size_t mem_size)
{
    song_list.reserve(songs);
    std::cin.read(mem, mem_size);

    const char* c = mem;
    const char* end = mem + mem_size;
    std::string_view plays;
    int song_pos = 1;
    int str_len = 0;

    while (song_pos <= songs && ++c < end)
    {
        if (*c == ' ')
        {
            plays = std::string_view(c - str_len, str_len);
            str_len = 0;
            ++c;
        }
        else if (*c == '\n')
        {
            auto listens = unsafe_strtol(plays);
            auto title = std::string_view(c - str_len, str_len);
            song_list.emplace_back(title, listens * song_pos++);
            str_len = 0;
            ++c;    
        }
        ++str_len;
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rax
movl %edi, %ebp
movslq %edi, %rsi
movq %rax, 0x18(%rsp)
movq %rax, %rdi
callq 0x260c
movq 0x3c84(%rip), %rdi      # 0x5fe0
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2160
addq %r12, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
xorl %eax, %eax
pushq $0x1
popq %r13
cmpl %ebp, %r13d
jg 0x23ef
leaq 0x1(%r12), %r15
cmpq %rbx, %r15
jae 0x23ef
movzbl (%r15), %ecx
movslq %eax, %r14
cmpl $0xa, %ecx
je 0x23a7
cmpl $0x20, %ecx
jne 0x23e8
subq %r14, %r15
movq %r14, (%rsp)
movq %r15, 0x8(%rsp)
jmp 0x23df
movq %rsp, %rdi
callq 0x26d1
subq %r14, %r15
movq %r14, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movslq %r13d, %rcx
incl %r13d
imulq %rax, %rcx
movq %rcx, 0x20(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x26f8
addq $0x2, %r12
xorl %eax, %eax
movq %r12, %r15
incl %eax
movq %r15, %r12
jmp 0x2379
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::Clear()
void TiXmlNode::Clear()
{
	TiXmlNode* node = firstChild;
	TiXmlNode* temp = 0;

	while ( node )
	{
		temp = node;
		node = node->next;
		delete temp;
	}	

	firstChild = 0;
	lastChild = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
addq $0x28, %rbx
testq %rdi, %rdi
je 0x35bd
movq (%rdi), %rax
movq 0x48(%rdi), %r14
callq *0x8(%rax)
movq %r14, %rdi
jmp 0x35a9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::LinkEndChild(TiXmlNode*)
TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node )
{
	assert( node->parent == 0 || node->parent == this );
	assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() );

	if ( node->Type() == TiXmlNode::TINYXML_DOCUMENT )
	{
		delete node;
		if ( GetDocument() ) 
			GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}

	node->parent = this;

	node->prev = lastChild;
	node->next = 0;

	if ( lastChild )
		lastChild->next = node;
	else
		firstChild = node;			// it was an empty list.

	lastChild = node;
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x18(%rsi), %rax
testq %rax, %rax
sete %cl
cmpq %rdi, %rax
sete %al
orb %cl, %al
je 0x3686
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3c9a
testq %rax, %rax
je 0x3618
movq %rbx, %rdi
callq 0x3c9a
movq %rax, %r15
movq %r14, %rdi
callq 0x3c9a
cmpq %rax, %r15
jne 0x36a5
cmpl $0x0, 0x20(%rbx)
je 0x3647
movq %r14, 0x18(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
leaq 0x28(%r14), %rcx
leaq 0x48(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %rbx, (%rdx)
movq %rbx, 0x30(%r14)
jmp 0x367d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x3c9a
testq %rax, %rax
je 0x367b
movq %r14, %rdi
callq 0x3c9a
xorl %ebx, %ebx
pushq $0xf
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6760
jmp 0x367d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5980(%rip), %rdi      # 0x900d
leaq 0x59a3(%rip), %rsi      # 0x9037
leaq 0x59a8(%rip), %rcx      # 0x9043
movl $0xbc, %edx
callq 0x30e0
leaq 0x59c7(%rip), %rdi      # 0x9073
leaq 0x5984(%rip), %rsi      # 0x9037
leaq 0x5989(%rip), %rcx      # 0x9043
movl $0xbd, %edx
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::InsertEndChild(TiXmlNode const&)
TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis )
{
	if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
	{
		if ( GetDocument() ) 
			GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}
	TiXmlNode* node = addThis.Clone();
	if ( !node )
		return 0;

	return LinkEndChild( node );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x20(%rsi)
je 0x36eb
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x3712
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x35cc
movq %rbx, %rdi
callq 0x3c9a
testq %rax, %rax
je 0x3712
movq %rbx, %rdi
callq 0x3c9a
pushq $0xf
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6760
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::InsertBeforeChild(TiXmlNode*, TiXmlNode const&)
TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis )
{	
	if ( !beforeThis || beforeThis->parent != this ) {
		return 0;
	}
	if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
	{
		if ( GetDocument() ) 
			GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}

	TiXmlNode* node = addThis.Clone();
	if ( !node )
		return 0;
	node->parent = this;

	node->next = beforeThis;
	node->prev = beforeThis->prev;
	if ( beforeThis->prev )
	{
		beforeThis->prev->next = node;
	}
	else
	{
		assert( firstChild == beforeThis );
		firstChild = node;
	}
	beforeThis->prev = node;
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x372c
movq %rsi, %r14
movq %rdi, %r15
cmpq %rdi, 0x18(%rsi)
je 0x3737
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x20(%rdx)
je 0x376c
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x372c
movq %rax, %rbx
movq %r15, 0x18(%rax)
movq %r14, 0x48(%rax)
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x3797
addq $0x48, %rax
jmp 0x37a4
movq %r15, %rdi
callq 0x3c9a
testq %rax, %rax
je 0x372c
movq %r15, %rdi
callq 0x3c9a
xorl %ebx, %ebx
pushq $0xf
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6760
jmp 0x372e
cmpq %r14, 0x28(%r15)
jne 0x37ad
addq $0x28, %r15
movq %r15, %rax
movq %rbx, (%rax)
movq %rbx, 0x40(%r14)
jmp 0x372e
leaq 0x5906(%rip), %rdi      # 0x90ba
leaq 0x587c(%rip), %rsi      # 0x9037
leaq 0x5911(%rip), %rcx      # 0x90d3
movl $0xff, %edx
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::InsertAfterChild(TiXmlNode*, TiXmlNode const&)
TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis )
{
	if ( !afterThis || afterThis->parent != this ) {
		return 0;
	}
	if ( addThis.Type() == TiXmlNode::TINYXML_DOCUMENT )
	{
		if ( GetDocument() ) 
			GetDocument()->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}

	TiXmlNode* node = addThis.Clone();
	if ( !node )
		return 0;
	node->parent = this;

	node->prev = afterThis;
	node->next = afterThis->next;
	if ( afterThis->next )
	{
		afterThis->next->prev = node;
	}
	else
	{
		assert( lastChild == afterThis );
		lastChild = node;
	}
	afterThis->next = node;
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x37e2
movq %rsi, %r14
movq %rdi, %r15
cmpq %rdi, 0x18(%rsi)
je 0x37ed
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x20(%rdx)
je 0x3822
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x37e2
movq %rax, %rbx
movq %r15, 0x18(%rax)
movq %r14, 0x40(%rax)
movq 0x48(%r14), %rax
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x384d
addq $0x40, %rax
jmp 0x385a
movq %r15, %rdi
callq 0x3c9a
testq %rax, %rax
je 0x37e2
movq %r15, %rdi
callq 0x3c9a
xorl %ebx, %ebx
pushq $0xf
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6760
jmp 0x37e4
cmpq %r14, 0x30(%r15)
jne 0x3863
addq $0x30, %r15
movq %r15, %rax
movq %rbx, (%rax)
movq %rbx, 0x48(%r14)
jmp 0x37e4
leaq 0x58b1(%rip), %rdi      # 0x911b
leaq 0x57c6(%rip), %rsi      # 0x9037
leaq 0x58ba(%rip), %rcx      # 0x9132
movl $0x120, %edx            # imm = 0x120
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::ReplaceChild(TiXmlNode*, TiXmlNode const&)
TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis )
{
	if ( !replaceThis )
		return 0;

	if ( replaceThis->parent != this )
		return 0;

	if ( withThis.ToDocument() ) {
		// A document can never be a child.	Thanks to Noam.
		TiXmlDocument* document = GetDocument();
		if ( document ) 
			document->SetError( TIXML_ERROR_DOCUMENT_TOP_ONLY, 0, 0, TIXML_ENCODING_UNKNOWN );
		return 0;
	}

	TiXmlNode* node = withThis.Clone();
	if ( !node )
		return 0;

	node->next = replaceThis->next;
	node->prev = replaceThis->prev;

	if ( replaceThis->next )
		replaceThis->next->prev = node;
	else
		lastChild = node;

	if ( replaceThis->prev )
		replaceThis->prev->next = node;
	else
		firstChild = node;

	delete replaceThis;
	node->parent = this;
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x3898
movq %rsi, %r15
movq %rdi, %r14
cmpq %rdi, 0x18(%rsi)
je 0x38a3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %rbx
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x20(%rax)
testq %rax, %rax
je 0x38d7
movq %r14, %rdi
callq 0x3c9a
testq %rax, %rax
je 0x3898
xorl %ebx, %ebx
pushq $0xf
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6760
jmp 0x389a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
testq %rax, %rax
je 0x3898
movq %rax, %rbx
movq 0x48(%r15), %rcx
movq %rcx, 0x48(%rax)
movq 0x40(%r15), %rax
movq %rax, 0x40(%rbx)
testq %rcx, %rcx
je 0x390a
movq %rbx, 0x40(%rcx)
movq 0x40(%r15), %rax
jmp 0x390e
movq %rbx, 0x30(%r14)
leaq 0x48(%rax), %rcx
leaq 0x28(%r14), %rdx
testq %rax, %rax
cmoveq %rdx, %rcx
movq %rbx, (%rcx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %r14, 0x18(%rbx)
jmp 0x389a
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::RemoveChild(TiXmlNode*)
bool TiXmlNode::RemoveChild( TiXmlNode* removeThis )
{
	if ( !removeThis ) {
		return false;
	}

	if ( removeThis->parent != this )
	{	
		assert( 0 );
		return false;
	}

	if ( removeThis->next )
		removeThis->next->prev = removeThis->prev;
	else
		lastChild = removeThis->prev;

	if ( removeThis->prev )
		removeThis->prev->next = removeThis->next;
	else
		firstChild = removeThis->next;

	delete removeThis;
	return true;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3976
cmpq %rdi, 0x18(%rbx)
jne 0x397e
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
leaq 0x30(%rdi), %rdx
leaq 0x40(%rcx), %rsi
testq %rcx, %rcx
cmoveq %rdx, %rsi
movq %rax, (%rsi)
leaq 0x48(%rax), %rdx
addq $0x28, %rdi
testq %rax, %rax
cmovneq %rdx, %rdi
movq %rcx, (%rdi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
testq %rbx, %rbx
setne %al
popq %rbx
retq
leaq 0x57f4(%rip), %rdi      # 0x9179
leaq 0x56ab(%rip), %rsi      # 0x9037
leaq 0x57e8(%rip), %rcx      # 0x917b
movl $0x157, %edx            # imm = 0x157
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::FirstChild(char const*) const
const TiXmlNode* TiXmlNode::FirstChild( const char * _value ) const
{
	const TiXmlNode* node;
	for ( node = firstChild; node; node = node->next )
	{
		if ( strcmp( node->Value(), _value ) == 0 )
			return node;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x39ce
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x39ce
addq $0x48, %rbx
jmp 0x39ac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::LastChild(char const*) const
const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const
{
	const TiXmlNode* node;
	for ( node = lastChild; node; node = node->prev )
	{
		if ( strcmp( node->Value(), _value ) == 0 )
			return node;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x30, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x3a0a
movq 0x38(%rbx), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x31e0
testl %eax, %eax
je 0x3a0a
addq $0x40, %rbx
jmp 0x39e8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::IterateChildren(TiXmlNode const*) const
const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const
{
	if ( !previous )
	{
		return FirstChild();
	}
	else
	{
		assert( previous->parent == this );
		return previous->NextSibling();
	}
}

// Assembly:
testq %rsi, %rsi
je 0x3a2a
cmpq %rdi, 0x18(%rsi)
jne 0x3a32
addq $0x48, %rsi
movq %rsi, %rdi
jmp 0x3a2e
addq $0x28, %rdi
movq (%rdi), %rax
retq
pushq %rax
leaq 0x576a(%rip), %rdi      # 0x91a4
leaq 0x55f6(%rip), %rsi      # 0x9037
leaq 0x5775(%rip), %rcx      # 0x91bd
movl $0x189, %edx            # imm = 0x189
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::IterateChildren(char const*, TiXmlNode const*) const
const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const
{
	if ( !previous )
	{
		return FirstChild( val );
	}
	else
	{
		assert( previous->parent == this );
		return previous->NextSibling( val );
	}
}

// Assembly:
testq %rdx, %rdx
je 0x399e
cmpq %rdi, 0x18(%rdx)
jne 0x3a69
movq %rdx, %rdi
jmp 0x3a8a
pushq %rax
leaq 0x5733(%rip), %rdi      # 0x91a4
leaq 0x55bf(%rip), %rsi      # 0x9037
leaq 0x5783(%rip), %rcx      # 0x9202
movl $0x197, %edx            # imm = 0x197
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::RemoveAttribute(char const*)
void TiXmlElement::RemoveAttribute( const char * name )
{
    #ifdef TIXML_USE_STL
	TIXML_STRING str( name );
	TiXmlAttribute* node = attributeSet.Find( str );
	#else
	TiXmlAttribute* node = attributeSet.Find( name );
	#endif
	if ( node )
	{
		attributeSet.Remove( node );
		delete node;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x3b2c
testq %rax, %rax
je 0x3b24
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b64
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttributeSet::Remove(TiXmlAttribute*)
void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe )
{
	TiXmlAttribute* node;

	for( node = sentinel.next; node != &sentinel; node = node->next )
	{
		if ( node == removeMe )
		{
			node->prev->next = node->next;
			node->next->prev = node->prev;
			node->next = 0;
			node->prev = 0;
			return;
		}
	}
	assert( 0 );		// we tried to remove a non-linked attribute.
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq 0x38(%rax), %rax
cmpq %rdi, %rax
je 0x3b8f
cmpq %rsi, %rax
jne 0x3b68
movq 0x30(%rax), %rcx
movq 0x38(%rax), %rdx
movq %rdx, 0x38(%rcx)
movq %rcx, 0x30(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
popq %rax
retq
leaq 0x55e3(%rip), %rdi      # 0x9179
leaq 0x549a(%rip), %rsi      # 0x9037
leaq 0x5944(%rip), %rcx      # 0x94e8
movl $0x608, %edx            # imm = 0x608
callq 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::FirstChildElement() const
const TiXmlElement* TiXmlNode::FirstChildElement() const
{
	const TiXmlNode* node;

	for (	node = FirstChild();
			node;
			node = node->NextSibling() )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x3bd2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x3bd6
addq $0x48, %rbx
jmp 0x3bb6
xorl %eax, %eax
popq %rbx
retq
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x28(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::FirstChildElement(char const*) const
const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const
{
	const TiXmlNode* node;

	for (	node = FirstChild( _value );
			node;
			node = node->NextSibling( _value ) )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x399e
movq %rax, %r14
testq %rax, %rax
je 0x3c0f
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
jne 0x3c19
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a8a
jmp 0x3bec
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::NextSiblingElement() const
const TiXmlElement* TiXmlNode::NextSiblingElement() const
{
	const TiXmlNode* node;

	for (	node = NextSibling();
			node;
			node = node->NextSibling() )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x3c4f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0x3c2e
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x28(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::NextSiblingElement(char const*) const
const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const
{
	const TiXmlNode* node;

	for (	node = NextSibling( _value );
			node;
			node = node->NextSibling( _value ) )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a8a
testq %rax, %rax
je 0x3c8f
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x28(%rax)
testq %rax, %rax
je 0x3c5e
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x28(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::GetDocument() const
const TiXmlDocument* TiXmlNode::GetDocument() const
{
	const TiXmlNode* node;

	for( node = this; node; node = node->parent )
	{
		if ( node->ToDocument() )
			return node->ToDocument();
	}
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x3cb7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
testq %rax, %rax
jne 0x3cbb
movq 0x18(%rbx), %rbx
jmp 0x3c9e
xorl %eax, %eax
popq %rbx
retq
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x20(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::CopyTo(TiXmlElement*) const
void TiXmlElement::CopyTo( TiXmlElement* target ) const
{
	// superclass:
	TiXmlNode::CopyTo( target );

	// Element class: 
	// Clone the attributes, then clone the children.
	const TiXmlAttribute* attribute = 0;
	for(	attribute = attributeSet.First();
	attribute;
	attribute = attribute->Next() )
	{
		target->SetAttribute( attribute->Name(), attribute->Value() );
	}

	TiXmlNode* node = 0;
	for ( node = firstChild; node; node = node->NextSibling() )
	{
		target->LinkEndChild( node->Clone() );
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3566
leaq 0x50(%r14), %rax
movq 0x88(%r14), %rcx
xorl %r15d, %r15d
cmpq %rax, %rcx
cmovneq %rcx, %r15
testq %r15, %r15
je 0x3dd9
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq $0x10, %rsi
addq $0x10, %rdx
movq %rbx, %rdi
callq 0x422c
movq %r15, %rdi
callq 0x442e
movq %rax, %r15
jmp 0x3daf
addq $0x28, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x3e02
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x35cc
addq $0x48, %r14
jmp 0x3ddd
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::ClearThis()
void TiXmlElement::ClearThis()
{
	Clear();
	while( attributeSet.First() )
	{
		TiXmlAttribute* node = attributeSet.First();
		attributeSet.Remove( node );
		delete node;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x359a
leaq 0x50(%rbx), %r14
movq 0x88(%rbx), %r15
cmpq %r14, %r15
je 0x3e66
testq %r15, %r15
je 0x3e66
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b64
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0x3e3f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Attribute(char const*, int*) const
const char* TiXmlElement::Attribute( const char* name, int* i ) const
{
	const TiXmlAttribute* attrib = attributeSet.Find( name );
	const char* result = 0;

	if ( attrib ) {
		result = attrib->Value();
		if ( i ) {
			attrib->QueryIntValue( i );
		}
	}
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
addq $0x50, %rdi
callq 0x3b2c
testq %rax, %rax
je 0x3eff
movq 0x28(%rax), %r14
addq $0x10, %r14
testq %rbx, %rbx
je 0x3f02
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3f0e
jmp 0x3f02
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Attribute(char const*, double*) const
const char* TiXmlElement::Attribute( const char* name, double* d ) const
{
	const TiXmlAttribute* attrib = attributeSet.Find( name );
	const char* result = 0;

	if ( attrib ) {
		result = attrib->Value();
		if ( d ) {
			attrib->QueryDoubleValue( d );
		}
	}
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
addq $0x50, %rdi
callq 0x3b2c
testq %rax, %rax
je 0x3f65
movq 0x28(%rax), %r14
addq $0x10, %r14
testq %rbx, %rbx
je 0x3f68
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3f74
jmp 0x3f68
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::QueryUnsignedAttribute(char const*, unsigned int*) const
int TiXmlElement::QueryUnsignedAttribute( const char* name, unsigned* value ) const
{
	const TiXmlAttribute* node = attributeSet.Find( name );
	if ( !node )
		return TIXML_NO_ATTRIBUTE;

	int ival = 0;
	int result = node->QueryIntValue( &ival );
	*value = (unsigned)ival;
	return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
addq $0x50, %rdi
callq 0x3b2c
testq %rax, %rax
je 0x3ff0
leaq 0x4(%rsp), %r14
andl $0x0, (%r14)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3f0e
movl (%r14), %ecx
movl %ecx, (%rbx)
jmp 0x3ff3
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::QueryBoolAttribute(char const*, bool*) const
int TiXmlElement::QueryBoolAttribute( const char* name, bool* bval ) const
{
	const TiXmlAttribute* node = attributeSet.Find( name );
	if ( !node )
		return TIXML_NO_ATTRIBUTE;
	
	int result = TIXML_WRONG_TYPE;
	if (    StringEqual( node->Value(), "true", true, TIXML_ENCODING_UNKNOWN ) 
		 || StringEqual( node->Value(), "yes", true, TIXML_ENCODING_UNKNOWN ) 
		 || StringEqual( node->Value(), "1", true, TIXML_ENCODING_UNKNOWN ) ) 
	{
		*bval = true;
		result = TIXML_SUCCESS;
	}
	else if (    StringEqual( node->Value(), "false", true, TIXML_ENCODING_UNKNOWN ) 
			  || StringEqual( node->Value(), "no", true, TIXML_ENCODING_UNKNOWN ) 
			  || StringEqual( node->Value(), "0", true, TIXML_ENCODING_UNKNOWN ) ) 
	{
		*bval = false;
		result = TIXML_SUCCESS;
	}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
addq $0x50, %rdi
callq 0x3b2c
testq %rax, %rax
je 0x40e0
movq %rax, %r14
movq 0x28(%rax), %rdi
addq $0x10, %rdi
leaq 0x522b(%rip), %rsi      # 0x9255
pushq $0x1
popq %rdx
xorl %ebp, %ebp
xorl %ecx, %ecx
callq 0x632a
movb $0x1, %r15b
testb %al, %al
jne 0x40db
movq 0x28(%r14), %rdi
addq $0x10, %rdi
leaq 0x520a(%rip), %rsi      # 0x925a
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x632a
testb %al, %al
jne 0x40db
movq 0x28(%r14), %rdi
addq $0x10, %rdi
leaq 0x561d(%rip), %rsi      # 0x968a
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x632a
testb %al, %al
jne 0x40db
movq 0x28(%r14), %rdi
addq $0x10, %rdi
leaq 0x51d4(%rip), %rsi      # 0x925e
pushq $0x1
popq %rdx
xorl %r15d, %r15d
xorl %ecx, %ecx
callq 0x632a
testb %al, %al
jne 0x40db
movq 0x28(%r14), %rdi
addq $0x10, %rdi
leaq 0x51ba(%rip), %rsi      # 0x9264
pushq $0x1
popq %rdx
xorl %r15d, %r15d
xorl %ecx, %ecx
callq 0x632a
testb %al, %al
jne 0x40db
movq 0x28(%r14), %rdi
addq $0x10, %rdi
leaq 0x50af(%rip), %rsi      # 0x9179
pushq $0x1
popq %rdx
xorl %r15d, %r15d
xorl %ecx, %ecx
callq 0x632a
testb %al, %al
je 0x40f0
movb %r15b, (%rbx)
jmp 0x40e3
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2
jmp 0x40e2
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttributeSet::FindOrCreate(char const*)
TiXmlAttribute* TiXmlAttributeSet::FindOrCreate( const char* _name )
{
	TiXmlAttribute* attrib = Find( _name );
	if ( !attrib ) {
		attrib = new TiXmlAttribute();
		Add( attrib );
		attrib->SetName( _name );
	}
	return attrib;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3b2c
movq %rax, %r14
testq %rax, %rax
jne 0x4175
pushq $0x40
popq %rdi
callq 0x3130
movq %rax, %r14
movq %rax, %rdi
callq 0x5b0c
movq %r15, %rdi
movq %r14, %rsi
callq 0x53fe
movq %r14, %rdi
addq $0x20, %rdi
movq %rbx, %rsi
callq 0x5988
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttribute::Next() const
const TiXmlAttribute* TiXmlAttribute::Next() const
{
	// We are using knowledge of the sentinel. The sentinel
	// have a value or name.
	if ( next->value.empty() && next->name.empty() )
		return 0;
	return next;
}

// Assembly:
movq 0x38(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq $0x0, (%rcx)
je 0x443d
retq
movq 0x20(%rax), %rcx
cmpq $0x0, (%rcx)
jne 0x443c
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Accept(TiXmlVisitor*) const
bool TiXmlElement::Accept( TiXmlVisitor* visitor ) const
{
	if ( visitor->VisitEnter( *this, attributeSet.First() ) ) 
	{
		for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
		{
			if ( !node->Accept( visitor ) )
				break;
		}
	}
	return visitor->VisitExit( *this );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
movq 0x88(%rdi), %rcx
xorl %edx, %edx
cmpq %rax, %rcx
cmovneq %rcx, %rdx
movq (%rsi), %rax
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x449c
leaq 0x28(%rbx), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x449c
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
addq $0x48, %r15
testb %al, %al
jne 0x447d
movq (%r14), %rax
movq 0x28(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlElement::Clone() const
TiXmlNode* TiXmlElement::Clone() const
{
	TiXmlElement* clone = new TiXmlElement( Value() );
	if ( !clone )
		return 0;

	CopyTo( clone );
	return clone;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x90, %edi
callq 0x3130
movq %rax, %rbx
movq 0x38(%r14), %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x3cc6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d8a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x90, %esi
movq %rbx, %rdi
callq 0x3140
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::TiXmlDocument(char const*)
TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
	tabsize = 4;
	useMicrosoftBOM = false;
	value = documentName;
	ClearError();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3536
leaq 0xa6f7(%rip), %rax      # 0xeca8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x58(%rbx), %r14
leaq 0xac95(%rip), %rax      # 0xf258
movq %rax, 0x58(%rbx)
orl $-0x1, 0x68(%rbx)
movabsq $-0xfffffffc, %rax      # imm = 0xFFFFFFFF00000004
movq %rax, 0x60(%rbx)
movb $0x0, 0x6c(%rbx)
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x5988
movq %rbx, %rdi
callq 0x59ba
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x5cd8
movq %rbx, %rdi
callq 0x5906
movq %r15, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::CopyTo(TiXmlDocument*) const
void TiXmlDocument::CopyTo( TiXmlDocument* target ) const
{
	TiXmlNode::CopyTo( target );

	target->error = error;
	target->errorId = errorId;
	target->errorDesc = errorDesc;
	target->tabsize = tabsize;
	target->errorLocation = errorLocation;
	target->useMicrosoftBOM = useMicrosoftBOM;

	TiXmlNode* node = 0;
	for ( node = firstChild; node; node = node->NextSibling() )
	{
		target->LinkEndChild( node->Clone() );
	}	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3566
movb 0x50(%r14), %al
movb %al, 0x50(%rbx)
movl 0x54(%r14), %eax
movl %eax, 0x54(%rbx)
leaq 0x58(%r14), %rsi
leaq 0x58(%rbx), %rdi
callq 0x5a18
movl 0x60(%r14), %eax
movl %eax, 0x60(%rbx)
movq 0x64(%r14), %rax
movq %rax, 0x64(%rbx)
movb 0x6c(%r14), %al
movb %al, 0x6c(%rbx)
addq $0x28, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x46db
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x35cc
addq $0x48, %r14
jmp 0x46b6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::LoadFile(char const*, TiXmlEncoding)
bool TiXmlDocument::LoadFile( const char* _filename, TiXmlEncoding encoding )
{
	TIXML_STRING filename( _filename );
	value = filename;

	// reading in binary mode so that tinyxml can normalize the EOL
	FILE* file = TiXmlFOpen( value.c_str (), "rb" );	

	if ( file )
	{
		bool result = LoadFile( file, encoding );
		fclose( file );
		return result;
	}
	else
	{
		SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x59de
leaq 0x38(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a18
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x4b66(%rip), %rsi      # 0x92b4
callq 0x3190
testq %rax, %rax
je 0x4775
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x480a
movl %eax, %r14d
movq %r15, %rdi
callq 0x3120
jmp 0x478a
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6760
movq %rsp, %rdi
callq 0x5cd8
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x47a4
jmp 0x47a4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5cd8
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::SaveFile(char const*) const
bool TiXmlDocument::SaveFile( const char * filename ) const
{
	// The old c stuff lives on...
	FILE* fp = TiXmlFOpen( filename, "w" );
	if ( fp )
	{
		bool result = SaveFile( fp );
		fclose( fp );
		return result;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x4e45(%rip), %rsi      # 0x961c
movq %rax, %rdi
callq 0x3190
testq %rax, %rax
je 0x4800
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x49b8
movl %eax, %ebx
movq %r14, %rdi
callq 0x3120
movl %ebx, %eax
jmp 0x4802
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::Print(_IO_FILE*, int) const
void TiXmlDocument::Print( FILE* cfile, int depth ) const
{
	assert( cfile );
	for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
	{
		node->Print( cfile, depth );
		fprintf( cfile, "\n" );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4aa4
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
addq $0x28, %r15
pushq $0xa
popq %rbp
movq (%r15), %r15
testq %r15, %r15
je 0x4a99
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq *0x10(%rax)
movl %ebp, %edi
movq %r14, %rsi
callq 0x31c0
addq $0x48, %r15
jmp 0x4a73
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x47bc(%rip), %rdi      # 0x9267
leaq 0x4585(%rip), %rsi      # 0x9037
leaq 0x485c(%rip), %rcx      # 0x9315
movl $0x47b, %edx            # imm = 0x47B
callq 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlDocument::Accept(TiXmlVisitor*) const
bool TiXmlDocument::Accept( TiXmlVisitor* visitor ) const
{
	if ( visitor->VisitEnter( *this ) )
	{
		for ( const TiXmlNode* node=FirstChild(); node; node=node->NextSibling() )
		{
			if ( !node->Accept( visitor ) )
				break;
		}
	}
	return visitor->VisitExit( *this );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
testb %al, %al
je 0x4b02
leaq 0x28(%rbx), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x4b02
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x88(%rax)
addq $0x48, %r15
testb %al, %al
jne 0x4ae3
movq (%r14), %rax
movq 0x18(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttribute::Previous() const
const TiXmlAttribute* TiXmlAttribute::Previous() const
{
	// We are using knowledge of the sentinel. The sentinel
	// have a value or name.
	if ( prev->value.empty() && prev->name.empty() )
		return 0;
	return prev;
}

// Assembly:
movq 0x30(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq $0x0, (%rcx)
je 0x4b25
retq
movq 0x20(%rax), %rcx
cmpq $0x0, (%rcx)
jne 0x4b24
xorl %eax, %eax
retq