#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, unsigned char);
int /*<<< orphan*/ free(unsigned char *);
int /*<<< orphan*/ getCounter(unsigned char *, unsigned char *, unsigned long *,
                              unsigned int *, unsigned int, unsigned char *);
int /*<<< orphan*/ getDatagramSectionHeader(unsigned int *, unsigned int *,
                                            int /*<<< orphan*/,
                                            unsigned char *);
int /*<<< orphan*/ getIPDatagramHeader(unsigned long *, unsigned char *,
                                       unsigned int *, unsigned int *,
                                       unsigned int, unsigned char *);
int /*<<< orphan*/ getRTPHeader(unsigned char *, unsigned char *,
                                unsigned char *, unsigned int *,
                                unsigned long *, unsigned long *,
                                unsigned int *, unsigned int, unsigned char *);
int /*<<< orphan*/ getUDPDatagramHeader(unsigned int *, unsigned int *,
                                        unsigned int *, unsigned int,
                                        unsigned char *);
scalar_t__ malloc(int);
void processSection(unsigned int pid, unsigned long dest_ip,
                    unsigned int dest_port, FILE *ofh,
                    unsigned long *current_csrc, unsigned char *section) {
  unsigned int dat_len;
  unsigned int dat_slen;
  unsigned long ip_dest_add_number;
  unsigned char *ip_dest_add;
  unsigned int ip_len_bytes;
  unsigned int ip_len;
  unsigned int udp_dest_port;
  unsigned int udp_ulen;
  unsigned int udp_len;
  unsigned char rtp_ver;
  unsigned char rtp_csrc_count;
  unsigned char rtp_marker;
  unsigned int rtp_pt;
  unsigned long rtp_ssrc;
  unsigned long rtp_csrc;
  unsigned int rtp_len;
  unsigned char counter_byte3;
  unsigned char counter_byte4;
  unsigned long counter_int_value;
  unsigned int counter_len;
  unsigned int data_length;
  unsigned int total_header_length;
  unsigned int in_dex;
  unsigned long temp_current_csrc;
  ip_dest_add = (unsigned char *)malloc(sizeof(char) * 4 + 1);
  getDatagramSectionHeader(&dat_slen, &dat_len, 0, section);
  getIPDatagramHeader(&ip_dest_add_number, ip_dest_add, &ip_len_bytes, &ip_len,
                      dat_len, section);
  getUDPDatagramHeader(&udp_dest_port, &udp_ulen, &udp_len,
                       dat_len + ip_len_bytes, section);
  getRTPHeader(&rtp_ver, &rtp_csrc_count, &rtp_marker, &rtp_pt, &rtp_ssrc,
               &rtp_csrc, &rtp_len, dat_len + ip_len_bytes + udp_len, section);
  getCounter(&counter_byte3, &counter_byte4, &counter_int_value, &counter_len,
             dat_len + ip_len_bytes + udp_len + rtp_len, section);
  data_length = udp_ulen - 8 - rtp_len - counter_len;
  total_header_length =
      dat_len + ip_len_bytes + udp_len + rtp_len + counter_len;
  if ((dest_ip == ip_dest_add_number) && (dest_port == udp_dest_port)) {
    if ((rtp_ver == 2) && (rtp_marker == 0)) {
      if (*current_csrc == 0) {
        *current_csrc = rtp_csrc;
      }
      if (((rtp_csrc & 0x3F) == 0) && (counter_int_value == 0)) {
        *current_csrc = rtp_csrc;
      }
      if (*current_csrc == rtp_csrc) {
        if (data_length > 0) {
          for (in_dex = total_header_length;
               in_dex < (total_header_length + data_length); in_dex++) {
            fprintf(ofh, "%c", section[in_dex]);
          }
        }
      }
    } else if ((rtp_ver == 0) && (rtp_pt == 1) && (rtp_marker == 0)) {
      if (((rtp_csrc >> 28) & 0xF) != 0xB) {
        if ((counter_byte3 == 0x2) && (counter_byte4 == 0x1)) {
          for (in_dex = (total_header_length + 0x1B);
               in_dex < (total_header_length + data_length); in_dex++) {
            fprintf(ofh, "%c", section[in_dex]);
          }
          *current_csrc = ((section[total_header_length + 0x13] << 24) |
                           (section[total_header_length + 0x14] << 16) |
                           (section[total_header_length + 0x15] << 8) |
                           (section[total_header_length + 0x16]));
        } else if ((counter_byte3 == 0x2) && (counter_byte4 == 0x2)) {
          for (in_dex = (total_header_length);
               in_dex < (total_header_length + data_length); in_dex++) {
            fprintf(ofh, "%c", section[in_dex]);
          }
        } else if ((counter_byte3 == 0x1) && (counter_byte4 == 0x1)) {
          temp_current_csrc = ((section[total_header_length + 0x13] << 24) |
                               (section[total_header_length + 0x14] << 16) |
                               (section[total_header_length + 0x15] << 8) |
                               (section[total_header_length + 0x16]));
          if (*current_csrc == temp_current_csrc) {
            for (in_dex = (total_header_length + 0x1B);
                 in_dex < (total_header_length + data_length); in_dex++) {
              fprintf(ofh, "%c", section[in_dex]);
            }
          }
        }
      }
    }
  }
  free(ip_dest_add);
  return;
}


x86 assembly (clang, -O0):
<processSection>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    $0x5,%edi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rcx
lea    -0x38(%rbp),%rdi
lea    -0x34(%rbp),%rsi
xor    %edx,%edx
call   1050 <getDatagramSectionHeader@plt>
mov    -0x48(%rbp),%rsi
mov    -0x34(%rbp),%r8d
mov    -0x30(%rbp),%r9
lea    -0x40(%rbp),%rdi
lea    -0x4c(%rbp),%rdx
lea    -0x50(%rbp),%rcx
call   1090 <getIPDatagramHeader@plt>
mov    -0x34(%rbp),%ecx
add    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%r8
lea    -0x54(%rbp),%rdi
lea    -0x58(%rbp),%rsi
lea    -0x5c(%rbp),%rdx
call   1040 <getUDPDatagramHeader@plt>
mov    -0x34(%rbp),%r10d
add    -0x4c(%rbp),%r10d
add    -0x5c(%rbp),%r10d
mov    -0x30(%rbp),%rax
lea    -0x5d(%rbp),%rdi
lea    -0x5e(%rbp),%rsi
lea    -0x5f(%rbp),%rdx
lea    -0x64(%rbp),%rcx
lea    -0x70(%rbp),%r8
lea    -0x78(%rbp),%r9
lea    -0x7c(%rbp),%r11
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1060 <getRTPHeader@plt>
mov    -0x34(%rbp),%r8d
add    -0x4c(%rbp),%r8d
add    -0x5c(%rbp),%r8d
add    -0x7c(%rbp),%r8d
mov    -0x30(%rbp),%r9
lea    -0x7d(%rbp),%rdi
lea    -0x7e(%rbp),%rsi
lea    -0x88(%rbp),%rdx
lea    -0x8c(%rbp),%rcx
call   10a0 <getCounter@plt>
mov    -0x58(%rbp),%eax
sub    $0x8,%eax
sub    -0x7c(%rbp),%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x34(%rbp),%eax
add    -0x4c(%rbp),%eax
add    -0x5c(%rbp),%eax
add    -0x7c(%rbp),%eax
add    -0x8c(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    1637 <processSection+0x4b7>
mov    -0x14(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    1637 <processSection+0x4b7>
movzbl -0x5d(%rbp),%eax
cmp    $0x2,%eax
jne    1392 <processSection+0x212>
movzbl -0x5f(%rbp),%eax
cmp    $0x0,%eax
jne    1392 <processSection+0x212>
mov    -0x28(%rbp),%rax
cmpq   $0x0,(%rax)
jne    12e2 <processSection+0x162>
mov    -0x78(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x78(%rbp),%rax
and    $0x3f,%rax
cmp    $0x0,%rax
jne    130d <processSection+0x18d>
cmpq   $0x0,-0x88(%rbp)
jne    130d <processSection+0x18d>
mov    -0x78(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
cmp    -0x78(%rbp),%rax
jne    138d <processSection+0x20d>
cmpl   $0x0,-0x90(%rbp)
jbe    1388 <processSection+0x208>
mov    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
cmp    %ecx,%eax
jae    1383 <processSection+0x203>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%ecx
lea    0xc9a(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1070 <fprintf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1337 <processSection+0x1b7>
jmp    1388 <processSection+0x208>
jmp    138d <processSection+0x20d>
jmp    1632 <processSection+0x4b2>
movzbl -0x5d(%rbp),%eax
cmp    $0x0,%eax
jne    162d <processSection+0x4ad>
cmpl   $0x1,-0x64(%rbp)
jne    162d <processSection+0x4ad>
movzbl -0x5f(%rbp),%eax
cmp    $0x0,%eax
jne    162d <processSection+0x4ad>
mov    -0x78(%rbp),%rax
shr    $0x1c,%rax
and    $0xf,%rax
cmp    $0xb,%rax
je     1628 <processSection+0x4a8>
movzbl -0x7d(%rbp),%eax
cmp    $0x2,%eax
jne    14ab <processSection+0x32b>
movzbl -0x7e(%rbp),%eax
cmp    $0x1,%eax
jne    14ab <processSection+0x32b>
mov    -0x94(%rbp),%eax
add    $0x1b,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
cmp    %ecx,%eax
jae    1441 <processSection+0x2c1>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%ecx
lea    0xbdc(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1070 <fprintf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    13f5 <processSection+0x275>
mov    -0x30(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    $0x13,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    -0x30(%rbp),%rcx
mov    -0x94(%rbp),%edx
add    $0x14,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x94(%rbp),%edx
add    $0x15,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x94(%rbp),%edx
add    $0x16,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
jmp    1623 <processSection+0x4a3>
movzbl -0x7d(%rbp),%eax
cmp    $0x2,%eax
jne    1522 <processSection+0x3a2>
movzbl -0x7e(%rbp),%eax
cmp    $0x2,%eax
jne    1522 <processSection+0x3a2>
mov    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
cmp    %ecx,%eax
jae    151d <processSection+0x39d>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%ecx
lea    0xb00(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1070 <fprintf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    14d1 <processSection+0x351>
jmp    161e <processSection+0x49e>
movzbl -0x7d(%rbp),%eax
cmp    $0x1,%eax
jne    1619 <processSection+0x499>
movzbl -0x7e(%rbp),%eax
cmp    $0x1,%eax
jne    1619 <processSection+0x499>
mov    -0x30(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    $0x13,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    -0x30(%rbp),%rcx
mov    -0x94(%rbp),%edx
add    $0x14,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x94(%rbp),%edx
add    $0x15,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    -0x94(%rbp),%edx
add    $0x16,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
cltq
mov    %rax,-0xa0(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
cmp    -0xa0(%rbp),%rax
jne    1614 <processSection+0x494>
mov    -0x94(%rbp),%eax
add    $0x1b,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
cmp    %ecx,%eax
jae    160f <processSection+0x48f>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    -0x98(%rbp),%ecx
lea    0xa0e(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1070 <fprintf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    15c3 <processSection+0x443>
jmp    1614 <processSection+0x494>
jmp    1619 <processSection+0x499>
jmp    161e <processSection+0x49e>
jmp    1623 <processSection+0x4a3>
jmp    1628 <processSection+0x4a8>
jmp    162d <processSection+0x4ad>
jmp    1632 <processSection+0x4b2>
jmp    1637 <processSection+0x4b7>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<processSection>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,%r15
mov    %r8,0x20(%rsp)
mov    %rcx,%r12
mov    %edx,%r13d
mov    %rsi,%rbp
mov    $0x5,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
lea    0x5c(%rsp),%rdi
lea    0xc(%rsp),%rsi
xor    %edx,%edx
mov    %r15,%rcx
call   1050 <getDatagramSectionHeader@plt>
mov    0xc(%rsp),%r8d
lea    0x50(%rsp),%rdi
lea    0x10(%rsp),%rdx
lea    0x58(%rsp),%rcx
mov    %r14,%rsi
mov    %r15,%r9
call   1090 <getIPDatagramHeader@plt>
mov    0x10(%rsp),%ecx
add    0xc(%rsp),%ecx
lea    0x34(%rsp),%rdi
lea    0x30(%rsp),%rsi
lea    0x14(%rsp),%rdx
mov    %r15,%r8
call   1040 <getUDPDatagramHeader@plt>
mov    0x10(%rsp),%eax
add    0xc(%rsp),%eax
add    0x14(%rsp),%eax
sub    $0x8,%rsp
lea    0x24(%rsp),%rbx
lea    0x13(%rsp),%rdi
lea    0x23(%rsp),%rsi
lea    0x12(%rsp),%rdx
lea    0x34(%rsp),%rcx
lea    0x68(%rsp),%r8
lea    0x40(%rsp),%r9
push   %r15
push   %rax
push   %rbx
call   1070 <getRTPHeader@plt>
add    $0x20,%rsp
mov    0x10(%rsp),%r8d
add    0xc(%rsp),%r8d
add    0x14(%rsp),%r8d
add    0x1c(%rsp),%r8d
lea    0x9(%rsp),%rdi
lea    0x8(%rsp),%rsi
lea    0x48(%rsp),%rdx
lea    0x28(%rsp),%rcx
mov    %r15,%r9
call   10a0 <getCounter@plt>
cmp    %rbp,0x50(%rsp)
jne    13e9 <processSection+0x269>
cmp    %r13d,0x34(%rsp)
jne    13e9 <processSection+0x269>
mov    0x1c(%rsp),%ebp
add    0x28(%rsp),%ebp
mov    0x30(%rsp),%r13d
sub    %ebp,%r13d
add    0xc(%rsp),%ebp
add    0x10(%rsp),%ebp
add    0x14(%rsp),%ebp
lea    -0x8(%r13),%eax
mov    0xb(%rsp),%dl
mov    0xa(%rsp),%cl
cmp    $0x2,%dl
jne    131b <processSection+0x19b>
test   %cl,%cl
jne    131b <processSection+0x19b>
mov    0x20(%rsp),%rdi
mov    (%rdi),%rdx
mov    0x38(%rsp),%rcx
test   %rdx,%rdx
jne    12cd <processSection+0x14d>
mov    %rcx,(%rdi)
mov    %rcx,%rdx
mov    %ecx,%esi
and    $0x3f,%esi
or     0x48(%rsp),%rsi
jne    12df <processSection+0x15f>
mov    %rcx,(%rdi)
mov    %rcx,%rdx
cmp    %rcx,%rdx
jne    13e9 <processSection+0x269>
test   %eax,%eax
je     13e9 <processSection+0x269>
add    %ebp,%eax
cmp    %eax,%ebp
jae    13e9 <processSection+0x269>
mov    %ebp,%ebp
mov    %eax,%ebx
xchg   %ax,%ax
movsbl (%r15,%rbp,1),%edi
mov    %r12,%rsi
call   1060 <fputc@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1300 <processSection+0x180>
jmp    13e9 <processSection+0x269>
test   %dl,%dl
jne    13e9 <processSection+0x269>
cmpl   $0x1,0x2c(%rsp)
jne    13e9 <processSection+0x269>
test   %cl,%cl
jne    13e9 <processSection+0x269>
mov    $0xf0000000,%ecx
and    0x38(%rsp),%ecx
cmp    $0xb0000000,%ecx
je     13e9 <processSection+0x269>
mov    0x9(%rsp),%dl
mov    0x8(%rsp),%cl
cmp    $0x2,%dl
jne    1400 <processSection+0x280>
cmp    $0x1,%cl
jne    1400 <processSection+0x280>
mov    %r14,0x40(%rsp)
lea    0x1b(%rbp),%ecx
add    %ebp,%eax
cmp    %eax,%ecx
jae    13a6 <processSection+0x226>
mov    %r12,%rbx
mov    %ecx,%r12d
add    %r15,%r12
add    $0xffffffdd,%r13d
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl (%r12,%r14,1),%edi
mov    %rbx,%rsi
call   1060 <fputc@plt>
add    $0x1,%r14
cmp    %r14d,%r13d
jne    1390 <processSection+0x210>
lea    0x13(%rbp),%eax
movzbl (%r15,%rax,1),%eax
shl    $0x18,%eax
lea    0x14(%rbp),%ecx
movzbl (%r15,%rcx,1),%ecx
shl    $0x10,%rcx
cltq
or     %rcx,%rax
lea    0x15(%rbp),%ecx
movzbl (%r15,%rcx,1),%ecx
shl    $0x8,%rcx
or     %rax,%rcx
add    $0x16,%ebp
movzbl (%r15,%rbp,1),%eax
or     %rcx,%rax
mov    0x20(%rsp),%rcx
mov    %rax,(%rcx)
mov    0x40(%rsp),%r14
mov    %r14,%rdi
call   1030 <free@plt>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x2,%dl
jne    1438 <processSection+0x2b8>
cmp    $0x2,%cl
jne    1438 <processSection+0x2b8>
add    %ebp,%eax
cmp    %eax,%ebp
jae    13e9 <processSection+0x269>
mov    %ebp,%ebp
mov    %eax,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl (%r15,%rbp,1),%edi
mov    %r12,%rsi
call   1060 <fputc@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1420 <processSection+0x2a0>
jmp    13e9 <processSection+0x269>
cmp    $0x1,%dl
jne    13e9 <processSection+0x269>
cmp    $0x1,%cl
jne    13e9 <processSection+0x269>
lea    0x13(%rbp),%ecx
movzbl (%r15,%rcx,1),%ecx
shl    $0x18,%ecx
lea    0x14(%rbp),%edx
movzbl (%r15,%rdx,1),%edx
shl    $0x10,%rdx
movslq %ecx,%rcx
or     %rdx,%rcx
lea    0x15(%rbp),%edx
movzbl (%r15,%rdx,1),%edx
shl    $0x8,%rdx
or     %rcx,%rdx
lea    0x16(%rbp),%ecx
movzbl (%r15,%rcx,1),%ecx
or     %rdx,%rcx
mov    0x20(%rsp),%rdx
cmp    %rcx,(%rdx)
jne    13e9 <processSection+0x269>
lea    0x1b(%rbp),%ecx
add    %ebp,%eax
cmp    %eax,%ecx
jae    13e9 <processSection+0x269>
mov    %ecx,%eax
add    %rax,%r15
add    $0xffffffdd,%r13d
xor    %ebp,%ebp
movsbl (%r15,%rbp,1),%edi
mov    %r12,%rsi
call   1060 <fputc@plt>
add    $0x1,%rbp
cmp    %ebp,%r13d
jne    149f <processSection+0x31f>
jmp    13e9 <processSection+0x269>

LLVM IR (-O0):
@.str = [3 x i8] c"%c\00"
define void @processSection(i32 %0, i64 %1, i32 %2, i32* %3, i64* %4, i8* %5) {
%7 = alloca i32
%8 = alloca i64
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i64*
%12 = alloca i8*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i64
%16 = alloca i8*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i8
%23 = alloca i8
%24 = alloca i8
%25 = alloca i32
%26 = alloca i64
%27 = alloca i64
%28 = alloca i32
%29 = alloca i8
%30 = alloca i8
%31 = alloca i64
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i64
store i32 %0, i32* %7
store i64 %1, i64* %8
store i32 %2, i32* %9
store i32* %3, i32** %10
store i64* %4, i64** %11
store i8* %5, i8** %12
%37 = call i64 @malloc(i32 5)
%38 = inttoptr i64 %37 to i8*
store i8* %38, i8** %16
%39 = load i8*, i8** %12
%40 = call i32 @getDatagramSectionHeader(i32* %14, i32* %13, i32 0, i8* %39)
%41 = load i8*, i8** %16
%42 = load i32, i32* %13
%43 = load i8*, i8** %12
%44 = call i32 @getIPDatagramHeader(i64* %15, i8* %41, i32* %17, i32* %18, i32 %42, i8* %43)
%45 = load i32, i32* %13
%46 = load i32, i32* %17
%47 = add i32 %45, %46
%48 = load i8*, i8** %12
%49 = call i32 @getUDPDatagramHeader(i32* %19, i32* %20, i32* %21, i32 %47, i8* %48)
%50 = load i32, i32* %13
%51 = load i32, i32* %17
%52 = add i32 %50, %51
%53 = load i32, i32* %21
%54 = add i32 %52, %53
%55 = load i8*, i8** %12
%56 = call i32 @getRTPHeader(i8* %22, i8* %23, i8* %24, i32* %25, i64* %26, i64* %27, i32* %28, i32 %54, i8* %55)
%57 = load i32, i32* %13
%58 = load i32, i32* %17
%59 = add i32 %57, %58
%60 = load i32, i32* %21
%61 = add i32 %59, %60
%62 = load i32, i32* %28
%63 = add i32 %61, %62
%64 = load i8*, i8** %12
%65 = call i32 @getCounter(i8* %29, i8* %30, i64* %31, i32* %32, i32 %63, i8* %64)
%66 = load i32, i32* %20
%67 = sub i32 %66, 8
%68 = load i32, i32* %28
%69 = sub i32 %67, %68
%70 = load i32, i32* %32
%71 = sub i32 %69, %70
store i32 %71, i32* %33
%72 = load i32, i32* %13
%73 = load i32, i32* %17
%74 = add i32 %72, %73
%75 = load i32, i32* %21
%76 = add i32 %74, %75
%77 = load i32, i32* %28
%78 = add i32 %76, %77
%79 = load i32, i32* %32
%80 = add i32 %78, %79
store i32 %80, i32* %34
%81 = load i64, i64* %8
%82 = load i64, i64* %15
%83 = icmp eq i64 %81, %82
br i1 %83, label %84, label %328
84: ; preds = %6
%85 = load i32, i32* %9
%86 = load i32, i32* %19
%87 = icmp eq i32 %85, %86
br i1 %87, label %88, label %328
88: ; preds = %84
%89 = load i8, i8* %22
%90 = zext i8 %89 to i32
%91 = icmp eq i32 %90, 2
br i1 %91, label %92, label %143
92: ; preds = %88
%93 = load i8, i8* %24
%94 = zext i8 %93 to i32
%95 = icmp eq i32 %94, 0
br i1 %95, label %96, label %143
96: ; preds = %92
%97 = load i64*, i64** %11
%98 = load i64, i64* %97
%99 = icmp eq i64 %98, 0
br i1 %99, label %100, label %103
100: ; preds = %96
%101 = load i64, i64* %27
%102 = load i64*, i64** %11
store i64 %101, i64* %102
br label %103
103: ; preds = %100, %96
%104 = load i64, i64* %27
%105 = and i64 %104, 63
%106 = icmp eq i64 %105, 0
br i1 %106, label %107, label %113
107: ; preds = %103
%108 = load i64, i64* %31
%109 = icmp eq i64 %108, 0
br i1 %109, label %110, label %113
110: ; preds = %107
%111 = load i64, i64* %27
%112 = load i64*, i64** %11
store i64 %111, i64* %112
br label %113
113: ; preds = %110, %107, %103
%114 = load i64*, i64** %11
%115 = load i64, i64* %114
%116 = load i64, i64* %27
%117 = icmp eq i64 %115, %116
br i1 %117, label %118, label %142
118: ; preds = %113
%119 = load i32, i32* %33
%120 = icmp ugt i32 %119, 0
br i1 %120, label %121, label %141
121: ; preds = %118
%122 = load i32, i32* %34
store i32 %122, i32* %35
br label %123
123: ; preds = %137, %121
%124 = load i32, i32* %35
%125 = load i32, i32* %34
%126 = load i32, i32* %33
%127 = add i32 %125, %126
%128 = icmp ult i32 %124, %127
br i1 %128, label %129, label %140
129: ; preds = %123
%130 = load i32*, i32** %10
%131 = load i8*, i8** %12
%132 = load i32, i32* %35
%133 = zext i32 %132 to i64
%134 = getelementptr inbounds i8, i8* %131, i64 %133
%135 = load i8, i8* %134
%136 = call i32 @fprintf(i32* %130, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8 zeroext %135)
br label %137
137: ; preds = %129
%138 = load i32, i32* %35
%139 = add i32 %138, 1
store i32 %139, i32* %35
br label %123
140: ; preds = %123
br label %141
141: ; preds = %140, %118
br label %142
142: ; preds = %141, %113
br label %327
143: ; preds = %92, %88
%144 = load i8, i8* %22
%145 = zext i8 %144 to i32
%146 = icmp eq i32 %145, 0
br i1 %146, label %147, label %326
147: ; preds = %143
%148 = load i32, i32* %25
%149 = icmp eq i32 %148, 1
br i1 %149, label %150, label %326
150: ; preds = %147
%151 = load i8, i8* %24
%152 = zext i8 %151 to i32
%153 = icmp eq i32 %152, 0
br i1 %153, label %154, label %326
154: ; preds = %150
%155 = load i64, i64* %27
%156 = lshr i64 %155, 28
%157 = and i64 %156, 15
%158 = icmp ne i64 %157, 11
br i1 %158, label %159, label %325
159: ; preds = %154
%160 = load i8, i8* %29
%161 = zext i8 %160 to i32
%162 = icmp eq i32 %161, 2
br i1 %162, label %163, label %224
163: ; preds = %159
%164 = load i8, i8* %30
%165 = zext i8 %164 to i32
%166 = icmp eq i32 %165, 1
br i1 %166, label %167, label %224
167: ; preds = %163
%168 = load i32, i32* %34
%169 = add i32 %168, 27
store i32 %169, i32* %35
br label %170
170: ; preds = %184, %167
%171 = load i32, i32* %35
%172 = load i32, i32* %34
%173 = load i32, i32* %33
%174 = add i32 %172, %173
%175 = icmp ult i32 %171, %174
br i1 %175, label %176, label %187
176: ; preds = %170
%177 = load i32*, i32** %10
%178 = load i8*, i8** %12
%179 = load i32, i32* %35
%180 = zext i32 %179 to i64
%181 = getelementptr inbounds i8, i8* %178, i64 %180
%182 = load i8, i8* %181
%183 = call i32 @fprintf(i32* %177, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8 zeroext %182)
br label %184
184: ; preds = %176
%185 = load i32, i32* %35
%186 = add i32 %185, 1
store i32 %186, i32* %35
br label %170
187: ; preds = %170
%188 = load i8*, i8** %12
%189 = load i32, i32* %34
%190 = add i32 %189, 19
%191 = zext i32 %190 to i64
%192 = getelementptr inbounds i8, i8* %188, i64 %191
%193 = load i8, i8* %192
%194 = zext i8 %193 to i32
%195 = shl i32 %194, 24
%196 = load i8*, i8** %12
%197 = load i32, i32* %34
%198 = add i32 %197, 20
%199 = zext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %196, i64 %199
%201 = load i8, i8* %200
%202 = zext i8 %201 to i32
%203 = shl i32 %202, 16
%204 = or i32 %195, %203
%205 = load i8*, i8** %12
%206 = load i32, i32* %34
%207 = add i32 %206, 21
%208 = zext i32 %207 to i64
%209 = getelementptr inbounds i8, i8* %205, i64 %208
%210 = load i8, i8* %209
%211 = zext i8 %210 to i32
%212 = shl i32 %211, 8
%213 = or i32 %204, %212
%214 = load i8*, i8** %12
%215 = load i32, i32* %34
%216 = add i32 %215, 22
%217 = zext i32 %216 to i64
%218 = getelementptr inbounds i8, i8* %214, i64 %217
%219 = load i8, i8* %218
%220 = zext i8 %219 to i32
%221 = or i32 %213, %220
%222 = sext i32 %221 to i64
%223 = load i64*, i64** %11
store i64 %222, i64* %223
br label %324
224: ; preds = %163, %159
%225 = load i8, i8* %29
%226 = zext i8 %225 to i32
%227 = icmp eq i32 %226, 2
br i1 %227, label %228, label %252
228: ; preds = %224
%229 = load i8, i8* %30
%230 = zext i8 %229 to i32
%231 = icmp eq i32 %230, 2
br i1 %231, label %232, label %252
232: ; preds = %228
%233 = load i32, i32* %34
store i32 %233, i32* %35
br label %234
234: ; preds = %248, %232
%235 = load i32, i32* %35
%236 = load i32, i32* %34
%237 = load i32, i32* %33
%238 = add i32 %236, %237
%239 = icmp ult i32 %235, %238
br i1 %239, label %240, label %251
240: ; preds = %234
%241 = load i32*, i32** %10
%242 = load i8*, i8** %12
%243 = load i32, i32* %35
%244 = zext i32 %243 to i64
%245 = getelementptr inbounds i8, i8* %242, i64 %244
%246 = load i8, i8* %245
%247 = call i32 @fprintf(i32* %241, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8 zeroext %246)
br label %248
248: ; preds = %240
%249 = load i32, i32* %35
%250 = add i32 %249, 1
store i32 %250, i32* %35
br label %234
251: ; preds = %234
br label %323
252: ; preds = %228, %224
%253 = load i8, i8* %29
%254 = zext i8 %253 to i32
%255 = icmp eq i32 %254, 1
br i1 %255, label %256, label %322
256: ; preds = %252
%257 = load i8, i8* %30
%258 = zext i8 %257 to i32
%259 = icmp eq i32 %258, 1
br i1 %259, label %260, label %322
260: ; preds = %256
%261 = load i8*, i8** %12
%262 = load i32, i32* %34
%263 = add i32 %262, 19
%264 = zext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %261, i64 %264
%266 = load i8, i8* %265
%267 = zext i8 %266 to i32
%268 = shl i32 %267, 24
%269 = load i8*, i8** %12
%270 = load i32, i32* %34
%271 = add i32 %270, 20
%272 = zext i32 %271 to i64
%273 = getelementptr inbounds i8, i8* %269, i64 %272
%274 = load i8, i8* %273
%275 = zext i8 %274 to i32
%276 = shl i32 %275, 16
%277 = or i32 %268, %276
%278 = load i8*, i8** %12
%279 = load i32, i32* %34
%280 = add i32 %279, 21
%281 = zext i32 %280 to i64
%282 = getelementptr inbounds i8, i8* %278, i64 %281
%283 = load i8, i8* %282
%284 = zext i8 %283 to i32
%285 = shl i32 %284, 8
%286 = or i32 %277, %285
%287 = load i8*, i8** %12
%288 = load i32, i32* %34
%289 = add i32 %288, 22
%290 = zext i32 %289 to i64
%291 = getelementptr inbounds i8, i8* %287, i64 %290
%292 = load i8, i8* %291
%293 = zext i8 %292 to i32
%294 = or i32 %286, %293
%295 = sext i32 %294 to i64
store i64 %295, i64* %36
%296 = load i64*, i64** %11
%297 = load i64, i64* %296
%298 = load i64, i64* %36
%299 = icmp eq i64 %297, %298
br i1 %299, label %300, label %321
300: ; preds = %260
%301 = load i32, i32* %34
%302 = add i32 %301, 27
store i32 %302, i32* %35
br label %303
303: ; preds = %317, %300
%304 = load i32, i32* %35
%305 = load i32, i32* %34
%306 = load i32, i32* %33
%307 = add i32 %305, %306
%308 = icmp ult i32 %304, %307
br i1 %308, label %309, label %320
309: ; preds = %303
%310 = load i32*, i32** %10
%311 = load i8*, i8** %12
%312 = load i32, i32* %35
%313 = zext i32 %312 to i64
%314 = getelementptr inbounds i8, i8* %311, i64 %313
%315 = load i8, i8* %314
%316 = call i32 @fprintf(i32* %310, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8 zeroext %315)
br label %317
317: ; preds = %309
%318 = load i32, i32* %35
%319 = add i32 %318, 1
store i32 %319, i32* %35
br label %303
320: ; preds = %303
br label %321
321: ; preds = %320, %260
br label %322
322: ; preds = %321, %256, %252
br label %323
323: ; preds = %322, %251
br label %324
324: ; preds = %323, %187
br label %325
325: ; preds = %324, %154
br label %326
326: ; preds = %325, %150, %147, %143
br label %327
327: ; preds = %326, %142
br label %328
328: ; preds = %327, %84, %6
%329 = load i8*, i8** %16
%330 = call i32 @free(i8* %329)
ret void
}

LLVM IR (-O2):
define void @processSection(i32 %0, i64 %1, i32 %2, i32* nocapture %3, i64* nocapture %4, i8* %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8
%16 = alloca i8
%17 = alloca i8
%18 = alloca i32
%19 = alloca i64
%20 = alloca i64
%21 = alloca i32
%22 = alloca i8
%23 = alloca i8
%24 = alloca i64
%25 = alloca i32
%26 = bitcast i32* %7 to i8*
%27 = bitcast i32* %8 to i8*
%28 = bitcast i64* %9 to i8*
%29 = bitcast i32* %10 to i8*
%30 = bitcast i32* %11 to i8*
%31 = bitcast i32* %12 to i8*
%32 = bitcast i32* %13 to i8*
%33 = bitcast i32* %14 to i8*
%34 = bitcast i32* %18 to i8*
%35 = bitcast i64* %19 to i8*
%36 = bitcast i64* %20 to i8*
%37 = bitcast i32* %21 to i8*
%38 = bitcast i64* %24 to i8*
%39 = bitcast i32* %25 to i8*
%40 = tail call i64 @malloc(i32 5)
%41 = inttoptr i64 %40 to i8*
%42 = call i32 @getDatagramSectionHeader(i32* %8, i32* %7, i32 0, i8* %5)
%43 = load i32, i32* %7
%44 = call i32 @getIPDatagramHeader(i64* %9, i8* %41, i32* %10, i32* %11, i32 %43, i8* %5)
%45 = load i32, i32* %7
%46 = load i32, i32* %10
%47 = add i32 %46, %45
%48 = call i32 @getUDPDatagramHeader(i32* %12, i32* %13, i32* %14, i32 %47, i8* %5)
%49 = load i32, i32* %7
%50 = load i32, i32* %10
%51 = add i32 %50, %49
%52 = load i32, i32* %14
%53 = add i32 %51, %52
%54 = call i32 @getRTPHeader(i8* %15, i8* %16, i8* %17, i32* %18, i64* %19, i64* %20, i32* %21, i32 %53, i8* %5)
%55 = load i32, i32* %7
%56 = load i32, i32* %10
%57 = add i32 %56, %55
%58 = load i32, i32* %14
%59 = add i32 %57, %58
%60 = load i32, i32* %21
%61 = add i32 %59, %60
%62 = call i32 @getCounter(i8* %22, i8* %23, i64* %24, i32* %25, i32 %61, i8* %5)
%63 = load i32, i32* %13
%64 = load i32, i32* %21
%65 = load i32, i32* %25
%66 = add i32 %63, -8
%67 = add i32 %64, %65
%68 = sub i32 %66, %67
%69 = load i32, i32* %7
%70 = load i32, i32* %10
%71 = load i32, i32* %14
%72 = add i32 %67, %69
%73 = add i32 %72, %70
%74 = add i32 %73, %71
%75 = load i64, i64* %9
%76 = icmp eq i64 %75, %1
%77 = load i32, i32* %12
%78 = icmp eq i32 %77, %2
%79 = select i1 %76, i1 %78, i1 false
br i1 %79, label %80, label %246
80: ; preds = %6
%81 = load i8, i8* %15
%82 = icmp eq i8 %81, 2
%83 = load i8, i8* %17
%84 = icmp eq i8 %83, 0
%85 = select i1 %82, i1 %84, i1 false
br i1 %85, label %86, label %118
86: ; preds = %80
%87 = load i64, i64* %4
%88 = icmp eq i64 %87, 0
%89 = load i64, i64* %20
br i1 %88, label %90, label %91
90: ; preds = %86
store i64 %89, i64* %4
br label %91
91: ; preds = %86, %90
%92 = phi i64 [ %89, %90 ], [ %87, %86 ]
%93 = and i64 %89, 63
%94 = icmp eq i64 %93, 0
%95 = load i64, i64* %24
%96 = icmp eq i64 %95, 0
%97 = select i1 %94, i1 %96, i1 false
br i1 %97, label %98, label %99
98: ; preds = %91
store i64 %89, i64* %4
br label %99
99: ; preds = %98, %91
%100 = phi i64 [ %89, %98 ], [ %92, %91 ]
%101 = icmp eq i64 %100, %89
%102 = icmp ne i32 %68, 0
%103 = select i1 %101, i1 %102, i1 false
br i1 %103, label %104, label %246
104: ; preds = %99
%105 = add i32 %74, %68
%106 = icmp ult i32 %74, %105
br i1 %106, label %107, label %246
107: ; preds = %104
%108 = zext i32 %74 to i64
%109 = zext i32 %105 to i64
br label %110
110: ; preds = %107, %110
%111 = phi i64 [ %108, %107 ], [ %116, %110 ]
%112 = getelementptr inbounds i8, i8* %5, i64 %111
%113 = load i8, i8* %112
%114 = sext i8 %113 to i32
%115 = call i32 @fputc(i32 %114, i32* %3)
%116 = add nuw nsw i64 %111, 1
%117 = icmp eq i64 %116, %109
br i1 %117, label %246, label %110
118: ; preds = %80
%119 = icmp eq i8 %81, 0
%120 = load i32, i32* %18
%121 = icmp eq i32 %120, 1
%122 = select i1 %119, i1 %121, i1 false
%123 = select i1 %122, i1 %84, i1 false
br i1 %123, label %124, label %246
124: ; preds = %118
%125 = load i64, i64* %20
%126 = and i64 %125, 4026531840
%127 = icmp eq i64 %126, 2952790016
br i1 %127, label %246, label %128
128: ; preds = %124
%129 = load i8, i8* %22
%130 = icmp eq i8 %129, 2
%131 = load i8, i8* %23
%132 = icmp eq i8 %131, 1
%133 = select i1 %130, i1 %132, i1 false
br i1 %133, label %134, label %177
134: ; preds = %128
%135 = add i32 %74, 27
%136 = add i32 %74, %68
%137 = icmp ult i32 %135, %136
br i1 %137, label %138, label %149
138: ; preds = %134
%139 = zext i32 %135 to i64
br label %140
140: ; preds = %138, %140
%141 = phi i64 [ %139, %138 ], [ %146, %140 ]
%142 = getelementptr inbounds i8, i8* %5, i64 %141
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = call i32 @fputc(i32 %144, i32* %3)
%146 = add nuw nsw i64 %141, 1
%147 = trunc i64 %146 to i32
%148 = icmp eq i32 %136, %147
br i1 %148, label %149, label %140
149: ; preds = %140, %134
%150 = add i32 %74, 19
%151 = zext i32 %150 to i64
%152 = getelementptr inbounds i8, i8* %5, i64 %151
%153 = load i8, i8* %152
%154 = zext i8 %153 to i32
%155 = shl nuw i32 %154, 24
%156 = add i32 %74, 20
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %5, i64 %157
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
%161 = shl nuw nsw i32 %160, 16
%162 = or i32 %161, %155
%163 = add i32 %74, 21
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %5, i64 %164
%166 = load i8, i8* %165
%167 = zext i8 %166 to i32
%168 = shl nuw nsw i32 %167, 8
%169 = or i32 %162, %168
%170 = add i32 %74, 22
%171 = zext i32 %170 to i64
%172 = getelementptr inbounds i8, i8* %5, i64 %171
%173 = load i8, i8* %172
%174 = zext i8 %173 to i32
%175 = or i32 %169, %174
%176 = sext i32 %175 to i64
store i64 %176, i64* %4
br label %246
177: ; preds = %128
%178 = icmp eq i8 %131, 2
%179 = select i1 %130, i1 %178, i1 false
br i1 %179, label %180, label %194
180: ; preds = %177
%181 = add i32 %74, %68
%182 = icmp ult i32 %74, %181
br i1 %182, label %183, label %246
183: ; preds = %180
%184 = zext i32 %74 to i64
%185 = zext i32 %181 to i64
br label %186
186: ; preds = %183, %186
%187 = phi i64 [ %184, %183 ], [ %192, %186 ]
%188 = getelementptr inbounds i8, i8* %5, i64 %187
%189 = load i8, i8* %188
%190 = sext i8 %189 to i32
%191 = call i32 @fputc(i32 %190, i32* %3)
%192 = add nuw nsw i64 %187, 1
%193 = icmp eq i64 %192, %185
br i1 %193, label %246, label %186
194: ; preds = %177
%195 = icmp eq i8 %129, 1
%196 = select i1 %195, i1 %132, i1 false
br i1 %196, label %197, label %246
197: ; preds = %194
%198 = add i32 %74, 19
%199 = zext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %5, i64 %199
%201 = load i8, i8* %200
%202 = zext i8 %201 to i32
%203 = shl nuw i32 %202, 24
%204 = add i32 %74, 20
%205 = zext i32 %204 to i64
%206 = getelementptr inbounds i8, i8* %5, i64 %205
%207 = load i8, i8* %206
%208 = zext i8 %207 to i32
%209 = shl nuw nsw i32 %208, 16
%210 = or i32 %209, %203
%211 = add i32 %74, 21
%212 = zext i32 %211 to i64
%213 = getelementptr inbounds i8, i8* %5, i64 %212
%214 = load i8, i8* %213
%215 = zext i8 %214 to i32
%216 = shl nuw nsw i32 %215, 8
%217 = or i32 %210, %216
%218 = add i32 %74, 22
%219 = zext i32 %218 to i64
%220 = getelementptr inbounds i8, i8* %5, i64 %219
%221 = load i8, i8* %220
%222 = zext i8 %221 to i32
%223 = or i32 %217, %222
%224 = sext i32 %223 to i64
%225 = load i64, i64* %4
%226 = icmp eq i64 %225, %224
br i1 %226, label %227, label %246
227: ; preds = %197
%228 = add i32 %74, 27
%229 = add i32 %74, %68
%230 = icmp ult i32 %228, %229
br i1 %230, label %231, label %246
231: ; preds = %227
%232 = zext i32 %228 to i64
%233 = add i32 %69, %70
%234 = add i32 %233, %71
%235 = add i32 %234, %63
%236 = add i32 %235, -8
br label %237
237: ; preds = %231, %237
%238 = phi i64 [ %232, %231 ], [ %243, %237 ]
%239 = getelementptr inbounds i8, i8* %5, i64 %238
%240 = load i8, i8* %239
%241 = sext i8 %240 to i32
%242 = call i32 @fputc(i32 %241, i32* %3)
%243 = add nuw nsw i64 %238, 1
%244 = trunc i64 %243 to i32
%245 = icmp eq i32 %236, %244
br i1 %245, label %246, label %237
246: ; preds = %237, %186, %110, %227, %180, %104, %99, %124, %197, %194, %149, %118, %6
%247 = call i32 @free(i8* %41)
ret void
}