LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movb 0x88(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2e09
movq (%rsp), %rdi
addq $0x70, %rdi
callq 0x4d60
movq (%rsp), %rax
addq $0x38, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4850
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4880
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x48b0
testb $0x1, %al
jne 0x2dc3
jmp 0x2dfe
leaq 0x20(%rsp), %rdi
callq 0x48d0
movq (%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
addq $0x70, %rdi
leaq 0xc(%rsp), %rsi
callq 0x4b40
leaq 0x20(%rsp), %rdi
callq 0x49e0
jmp 0x2dae
movq (%rsp), %rax
movb $0x1, 0x88(%rax)
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3520
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0x3780
movq 0x8(%rsp), %rdi
callq 0x3820
movq 0x8(%rsp), %rdi
callq 0x3520
movq 0x8(%rsp), %rdi
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
subl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x78, %rdi
movl 0x14(%rsp), %esi
callq 0x4e30
movq 0x8(%rsp), %rdi
addq $0xa8, %rdi
movl 0x18(%rsp), %esi
callq 0x4e30
addq $0x28, %rsp
retq
nopl (%rax)
// File: yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::LinkDensity()
double DynamicalGraph::LinkDensity() {
  size_t n = m_species.size();
  if( n <= 1 ) { return 0.0; }
  size_t total = 0;
  for( auto s : m_species ) {
    total += s->OutDegree();
  }
  return static_cast<double>(total) / (n*(n-1));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
callq 0x4b20
movq %rax, 0x30(%rsp)
cmpq $0x1, 0x30(%rsp)
ja 0x3576
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x364a
movq (%rsp), %rax
movq $0x0, 0x28(%rsp)
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4850
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4880
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x48b0
testb $0x1, %al
jne 0x35bf
jmp 0x35f1
leaq 0x18(%rsp), %rdi
callq 0x48d0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2e30
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x49e0
jmp 0x35aa
movq 0x28(%rsp), %xmm0
movaps 0x7a12(%rip), %xmm3     # 0xb010
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x7a16(%rip), %xmm2     # 0xb020
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movq %rax, %rcx
decq %rcx
imulq %rcx, %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: DynamicalGraph::CC()
double DynamicalGraph::CC() {
  if( m_species.empty() ) { return 0.0; }
  double total = 0.0;
  for( auto s : m_species ) {
    double d = s->LocalCC();
    total += d;
  }
  return total / m_species.size();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
callq 0x50e0
testb $0x1, %al
jne 0x3682
jmp 0x3690
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x376b
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4850
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4880
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x48b0
testb $0x1, %al
jne 0x36da
jmp 0x371a
leaq 0x30(%rsp), %rdi
callq 0x48d0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2920
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x49e0
jmp 0x36c5
movq 0x10(%rsp), %rdi
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x8, %rdi
callq 0x4b20
movsd 0x8(%rsp), %xmm0
movq %rax, %xmm1
movaps 0x78ca(%rip), %xmm2     # 0xb010
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x78ce(%rip), %xmm2     # 0xb020
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb $0x1, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x384f
movq (%rsp), %rdi
callq 0x3a50
andb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x3837
movq (%rsp), %rdi
addq $0x38, %rdi
callq 0x4fc0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x88(%rsp), %rdi
xorps %xmm0, %xmm0
movsd 0x7789(%rip), %xmm1     # 0xb030
callq 0x4f10
leaq 0x68(%rsp), %rdi
callq 0x4f40
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x4850
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x4880
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x48b0
testb $0x1, %al
jne 0x38fa
jmp 0x3a0e
leaq 0x58(%rsp), %rdi
callq 0x48d0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x48(%rsp)
movq 0x70(%rax), %rsi
leaq 0x88(%rsp), %rdi
callq 0x4f60
movq 0x20(%rsp), %rax
movaps %xmm0, %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3970
movq 0x20(%rsp), %rax
movq 0x98(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x70(%rax), %rsi
leaq 0x68(%rsp), %rdi
callq 0x4f90
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2450
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rsi
leaq 0x88(%rsp), %rdi
callq 0x4f60
movq 0x20(%rsp), %rax
movaps %xmm0, %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x39fd
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x98(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x70(%rax), %rsi
leaq 0x68(%rsp), %rdi
callq 0x4f90
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2450
movq 0x48(%rsp), %rdi
callq 0x26c0
testb $0x1, %al
jne 0x39df
jmp 0x39fb
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
leaq 0x48(%rsp), %rsi
callq 0x4980
movq %rax, 0x38(%rsp)
movb %dl, 0x40(%rsp)
jmp 0x39fd
jmp 0x39ff
leaq 0x58(%rsp), %rdi
callq 0x49e0
jmp 0x38e2
movq 0x98(%rsp), %rdi
callq 0x26c0
testb $0x1, %al
jne 0x3a21
jmp 0x3a40
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
leaq 0x98(%rsp), %rsi
callq 0x4980
movq %rax, 0x28(%rsp)
movb %dl, 0x30(%rsp)
addq $0xa8, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
addq $0x38, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4850
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4880
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x48b0
testb $0x1, %al
jne 0x3ab0
jmp 0x3b04
leaq 0x20(%rsp), %rdi
callq 0x48d0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4fd0
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0x3af6
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x3af8
leaq 0x20(%rsp), %rdi
callq 0x49e0
jmp 0x3a9b
cmpq $0x0, 0x38(%rsp)
je 0x3b1a
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3b30
cmpq $0x0, 0x38(%rsp)
setne %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq 0x28(%rsp), %rdi
addq $0x38, %rsi
callq 0x2500
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
leaq 0x28(%rsp), %rsi
callq 0x47f0
movq 0x10(%rsp), %rax
movl 0x68(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4fe0
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movl 0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x24(%rsp)
addq $0xd8, %rdi
movl 0x24(%rsp), %esi
callq 0x4e30
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
leaq 0x28(%rsp), %rsi
callq 0x47f0
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x3bd7
movq 0x18(%rsp), %rdi
callq 0x4ff0
movq 0x18(%rsp), %rdi
callq 0x2180
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
addq $0xa8, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5100
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5130
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5160
testb $0x1, %al
jne 0x3e1e
jmp 0x3e5d
leaq 0x10(%rsp), %rdi
callq 0x5180
movq (%rax), %rax
movq %rax, (%rsp)
movl (%rsp), %eax
imull 0x4(%rsp), %eax
movl %eax, %eax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x4(%rsp), %eax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x51a0
jmp 0x3e09
movq 0x28(%rsp), %xmm0
movaps 0x71a6(%rip), %xmm3     # 0xb010
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x71aa(%rip), %xmm2     # 0xb020
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x20(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x1c(%rsp), %rsi
callq 0x63e0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x6410
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x63c0
testb $0x1, %al
jne 0x4e78
jmp 0x4e8f
movq (%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x6440
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4ea3
movq (%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x6440
movl $0x1, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movl %edi, 0x84(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movslq 0x84(%rsp), %rsi
callq 0x2920
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x8c40(%rip), %rdi      # 0xafe0
callq 0x2160
movq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x70(%rsp), %rax
addq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2a30
movl $0x1, 0x44(%rsp)
movl $0x0, 0x40(%rsp)
movl 0x44(%rsp), %ecx
xorl %eax, %eax
cmpl 0x84(%rsp), %ecx
movb %al, 0xf(%rsp)
jg 0x2405
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
cmpq 0x58(%rsp), %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2412
jmp 0x2506
movq 0x60(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x246f
movq 0x60(%rsp), %rsi
movslq 0x40(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq 0x40(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x2a50
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0x40(%rsp)
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x24f6
movq 0x60(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x24f4
leaq 0x48(%rsp), %rdi
callq 0x2a80
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rsi
movslq 0x40(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq 0x40(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x2a50
movq 0x78(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x44(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x44(%rsp)
movslq %ecx, %rcx
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x2b10
movl $0x0, 0x40(%rsp)
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x24f6
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x23d8
addq $0x88, %rsp
retq
nop
// File: noizebox[P]zipfsong/zipfsong_cpp_fast.cpp
// Function: unsafe_strtol(std::basic_string_view<char, std::char_traits<char>> const&)
inline uint64_t unsafe_strtol(const std::string_view& s)
{
    uint64_t res{0};
    for (auto c : s)
    {
        res = (res * 10) + (c - '0');
    }
    return res;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ed0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ee0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2afa
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
imulq $0xa, 0x28(%rsp), %rax
movsbl 0xf(%rsp), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2aba
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::TiXmlNode(TiXmlNode::NodeType)
TiXmlNode::TiXmlNode( NodeType _type ) : TiXmlBase()
{
	parent = 0;
	type = _type;
	firstChild = 0;
	lastChild = 0;
	prev = 0;
	next = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x7860
movq -0x28(%rbp), %rdi
leaq 0x100b1(%rip), %rax     # 0x13758
movq %rax, (%rdi)
addq $0x38, %rdi
callq 0x78a0
jmp 0x36b5
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x85f0
movq -0x18(%rbp), %rdi
callq 0x3270
nopl (%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::~TiXmlNode()
TiXmlNode::~TiXmlNode()
{
	TiXmlNode* node = firstChild;
	TiXmlNode* temp = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1001d(%rip), %rcx     # 0x13748
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3777
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3775
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3742
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x78c0
movq -0x20(%rbp), %rdi
callq 0x85f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3869
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3867
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3834
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x18(%rcx)
movb %al, -0x19(%rbp)
je 0x38ca
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, 0x18(%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x38d3
jmp 0x38d5
jmp 0x38f4
leaq 0xa731(%rip), %rdi      # 0xe00d
leaq 0xa754(%rip), %rsi      # 0xe037
movl $0xbc, %edx
leaq 0xa754(%rip), %rcx      # 0xe043
callq 0x30e0
movq -0x18(%rbp), %rdi
callq 0x7920
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
je 0x3931
movq -0x18(%rbp), %rdi
callq 0x7920
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x7920
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x393a
jmp 0x393c
jmp 0x395b
leaq 0xa730(%rip), %rdi      # 0xe073
leaq 0xa6ed(%rip), %rsi      # 0xe037
movl $0xbd, %edx
leaq 0xa6ed(%rip), %rcx      # 0xe043
callq 0x30e0
movq -0x18(%rbp), %rdi
callq 0x7940
cmpl $0x0, %eax
jne 0x39ba
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x3981
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0x7920
cmpq $0x0, %rax
je 0x39b0
movq -0x28(%rbp), %rdi
callq 0x7920
movq %rax, %rdi
movl $0xf, %esi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x9c50
movq $0x0, -0x8(%rbp)
jmp 0x3a17
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rax, 0x18(%rcx)
movq 0x30(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x40(%rcx)
movq -0x18(%rbp), %rcx
movq $0x0, 0x48(%rcx)
cmpq $0x0, 0x30(%rax)
je 0x39f7
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x30(%rax), %rax
movq %rcx, 0x48(%rax)
jmp 0x3a03
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7940
cmpl $0x0, %eax
jne 0x3a8f
movq -0x28(%rbp), %rdi
callq 0x7920
cmpq $0x0, %rax
je 0x3a85
movq -0x28(%rbp), %rdi
callq 0x7920
movq %rax, %rdi
movl $0xf, %esi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x9c50
movq $0x0, -0x8(%rbp)
jmp 0x3ac2
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3ab1
movq $0x0, -0x8(%rbp)
jmp 0x3ac2
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3890
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3b01
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, 0x18(%rax)
je 0x3b0e
movq $0x0, -0x8(%rbp)
jmp 0x3c11
movq -0x20(%rbp), %rdi
callq 0x7940
cmpl $0x0, %eax
jne 0x3b58
movq -0x30(%rbp), %rdi
callq 0x7920
cmpq $0x0, %rax
je 0x3b4b
movq -0x30(%rbp), %rdi
callq 0x7920
movq %rax, %rdi
movl $0xf, %esi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x9c50
movq $0x0, -0x8(%rbp)
jmp 0x3c11
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3b7d
movq $0x0, -0x8(%rbp)
jmp 0x3c11
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x3bc2
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x48(%rax)
jmp 0x3bfd
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x3bd2
jmp 0x3bf1
leaq 0xa4e1(%rip), %rdi      # 0xe0ba
leaq 0xa457(%rip), %rsi      # 0xe037
movl $0xff, %edx
leaq 0xa4e7(%rip), %rcx      # 0xe0d3
callq 0x30e0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3c51
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, 0x18(%rax)
je 0x3c5e
movq $0x0, -0x8(%rbp)
jmp 0x3d61
movq -0x20(%rbp), %rdi
callq 0x7940
cmpl $0x0, %eax
jne 0x3ca8
movq -0x30(%rbp), %rdi
callq 0x7920
cmpq $0x0, %rax
je 0x3c9b
movq -0x30(%rbp), %rdi
callq 0x7920
movq %rax, %rdi
movl $0xf, %esi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x9c50
movq $0x0, -0x8(%rbp)
jmp 0x3d61
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3ccd
movq $0x0, -0x8(%rbp)
jmp 0x3d61
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x3d12
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x40(%rax)
jmp 0x3d4d
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x3d22
jmp 0x3d41
leaq 0xa3f2(%rip), %rdi      # 0xe11b
leaq 0xa307(%rip), %rsi      # 0xe037
movl $0x120, %edx            # imm = 0x120
leaq 0xa3f6(%rip), %rcx      # 0xe132
callq 0x30e0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3da0
movq $0x0, -0x8(%rbp)
jmp 0x3ec7
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, 0x18(%rax)
je 0x3dbb
movq $0x0, -0x8(%rbp)
jmp 0x3ec7
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpq $0x0, %rax
je 0x3e04
movq -0x38(%rbp), %rdi
callq 0x7920
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3df7
movq -0x28(%rbp), %rdi
movl $0xf, %esi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x9c50
movq $0x0, -0x8(%rbp)
jmp 0x3ec7
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3e29
movq $0x0, -0x8(%rbp)
jmp 0x3ec7
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x3e66
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x40(%rax)
jmp 0x3e72
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x3e8f
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x48(%rax)
jmp 0x3e9b
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x3eb3
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3f08
movb $0x0, -0x1(%rbp)
jmp 0x3fb3
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, 0x18(%rax)
je 0x3f35
leaq 0xa25c(%rip), %rdi      # 0xe179
leaq 0xa113(%rip), %rsi      # 0xe037
movl $0x157, %edx            # imm = 0x157
leaq 0xa24b(%rip), %rcx      # 0xe17b
callq 0x30e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x3f56
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x40(%rax)
jmp 0x3f66
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x3f87
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x48(%rax)
jmp 0x3f97
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x48(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3faf
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4017
movq -0x20(%rbp), %rdi
callq 0x7960
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x31d0
cmpl $0x0, %eax
jne 0x4007
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x401f
jmp 0x4009
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3fdc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4087
movq -0x20(%rbp), %rdi
callq 0x7960
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x31d0
cmpl $0x0, %eax
jne 0x4077
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x408f
jmp 0x4079
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x404c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x40ce
movq -0x20(%rbp), %rdi
callq 0x7980
movq %rax, -0x8(%rbp)
jmp 0x410a
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, 0x18(%rax)
jne 0x40de
jmp 0x40fd
leaq 0xa0bf(%rip), %rdi      # 0xe1a4
leaq 0x9f4b(%rip), %rsi      # 0xe037
movl $0x189, %edx            # imm = 0x189
leaq 0xa0c5(%rip), %rcx      # 0xe1bd
callq 0x30e0
movq -0x18(%rbp), %rdi
callq 0x79a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4156
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3fc0
movq %rax, -0x8(%rbp)
jmp 0x4196
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, 0x18(%rax)
jne 0x4166
jmp 0x4185
leaq 0xa037(%rip), %rdi      # 0xe1a4
leaq 0x9ec3(%rip), %rsi      # 0xe037
movl $0x197, %edx            # imm = 0x197
leaq 0xa082(%rip), %rcx      # 0xe202
callq 0x30e0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::NextSibling(char const*) const
const TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const 
{
	const TiXmlNode* node;
	for ( node = next; node; node = node->next )
	{
		if ( strcmp( node->Value(), _value ) == 0 )
			return node;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x41f7
movq -0x20(%rbp), %rdi
callq 0x7960
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x31d0
cmpl $0x0, %eax
jne 0x41e7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x41ff
jmp 0x41e9
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x41bc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlNode::PreviousSibling(char const*) const
const TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const
{
	const TiXmlNode* node;
	for ( node = prev; node; node = node->prev )
	{
		if ( strcmp( node->Value(), _value ) == 0 )
			return node;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4267
movq -0x20(%rbp), %rdi
callq 0x7960
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x31d0
cmpl $0x0, %eax
jne 0x4257
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x426f
jmp 0x4259
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x422c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x42f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x42db
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x4370
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x42d9
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x42db
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallmuou[P]tinyhtml/tinyxml.cpp
// Function: TiXmlAttributeSet::Find(char const*) const
TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const
{
	for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node = node->next )
	{
		if ( strcmp( node->name.c_str(), name ) == 0 )
			return node;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x4355
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x7810
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x31d0
cmpl $0x0, %eax
jne 0x4345
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x435d
jmp 0x4347
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4310
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
je 0x43fd
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x43ed
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
jmp 0x43ef
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4390
leaq 0x9d75(%rip), %rdi      # 0xe179
leaq 0x9c2c(%rip), %rsi      # 0xe037
movl $0x608, %edx            # imm = 0x608
leaq 0xa0d1(%rip), %rcx      # 0xe4e8
callq 0x30e0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7980
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4471
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpq $0x0, %rax
je 0x4460
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, -0x8(%rbp)
jmp 0x4479
jmp 0x4462
movq -0x18(%rbp), %rdi
callq 0x79a0
movq %rax, -0x18(%rbp)
jmp 0x4439
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3fc0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x44ed
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpq $0x0, %rax
je 0x44d8
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, -0x8(%rbp)
jmp 0x44f5
jmp 0x44da
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41a0
movq %rax, -0x20(%rbp)
jmp 0x44b1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x79a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4551
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpq $0x0, %rax
je 0x4540
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, -0x8(%rbp)
jmp 0x4559
jmp 0x4542
movq -0x18(%rbp), %rdi
callq 0x79a0
movq %rax, -0x18(%rbp)
jmp 0x4519
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x45cd
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpq $0x0, %rax
je 0x45b8
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, -0x8(%rbp)
jmp 0x45d5
jmp 0x45ba
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41a0
movq %rax, -0x20(%rbp)
jmp 0x4591
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x462b
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpq $0x0, %rax
je 0x461b
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, -0x8(%rbp)
jmp 0x4633
jmp 0x461d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x45f4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x37b0
movq -0x28(%rbp), %rdi
movq $0x0, -0x18(%rbp)
addq $0x50, %rdi
callq 0x7aa0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x47fe
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7b00
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7a50
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x4fc0
movq -0x18(%rbp), %rdi
callq 0x5270
movq %rax, -0x18(%rbp)
jmp 0x47ba
movq -0x28(%rbp), %rax
movq $0x0, -0x20(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4849
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x3890
movq -0x20(%rbp), %rdi
callq 0x7ae0
movq %rax, -0x20(%rbp)
jmp 0x4812
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3810
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x7a10
cmpq $0x0, %rax
je 0x48f8
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x7a10
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x4370
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x48f6
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x48a9
addq $0x20, %rsp
popq %rbp
retq
nop