#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*/ data;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ bzero(char *, int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fflush(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ read(int, ...);
scalar_t__ strtol(unsigned char *, int /*<<< orphan*/ *, int);
void dataParser(int *pipe1, int *pipe2, int *pipe3, int conSocket) {
  char data[991];
  bzero(data, sizeof(data));
  data[991] = '\0';
  FILE *myFile = fopen("./Sresults.txt", "a");
  fprintf(myFile, "Starting MP TCP :: Server\n");
  printf("Control:: Reading\n");
  while (1) {
    unsigned char conBuff[10];
    read(conSocket, &conBuff, 9);
    conBuff[9] = '\0';
    printf("inc->  %s\n", conBuff);
    fprintf(myFile, "DSS :: %s\n", conBuff);
    fflush(myFile);
    char readBuff[4];
    if (conBuff[8] == '1') {
      unsigned char seqHex[] = {conBuff[0], conBuff[1], conBuff[2], conBuff[3],
                                '\0'};
      int seq;
      seq = (int)strtol(seqHex, NULL, 16);
      printf("seq num :: %d\n", seq);
      unsigned char indexHex[] = {conBuff[4], conBuff[5], conBuff[6],
                                  conBuff[7], '\0'};
      int index;
      index = (int)strtol(indexHex, NULL, 16);
      printf("index num :: %d\n", index);
      read(pipe1[0], &readBuff, 4);
      readBuff[4] = '\0';
      printf("Pipe 1 ->> %s\n", readBuff);
      if ((readBuff[0] == '#') && (readBuff[1] == 'F') &&
          (readBuff[2] == 'I') && (readBuff[3] == 'N')) {
        data[991] = '\0';
        printf("DATA :: %s\n", data);
        fprintf(myFile, "---Tranfer completed\n");
        fprintf(myFile, "%s\n", data);
        break;
      }
      int s;
      int pos = 0;
      for (s = index; s < index + 4; s++) {
        data[s] = readBuff[pos];
        pos++;
      }
      fprintf(myFile, "|SEQ :: INDEX :: DATA|\n");
      fprintf(myFile, "|%d :: %d :: %s|\n", seq, index, readBuff);
      fprintf(myFile, "--------------------\n");
      fflush(myFile);
    } else if (conBuff[8] == '2') {
      unsigned char seqHex[] = {conBuff[0], conBuff[1], conBuff[2], conBuff[3],
                                '\0'};
      int seq;
      seq = (int)strtol(seqHex, NULL, 16);
      printf("seq num :: %d\n", seq);
      unsigned char indexHex[] = {conBuff[4], conBuff[5], conBuff[6],
                                  conBuff[7], '\0'};
      int index;
      index = (int)strtol(indexHex, NULL, 16);
      printf("index num :: %d\n", index);
      read(pipe2[0], &readBuff, 4);
      readBuff[4] = '\0';
      printf("Pipe 2 ->> %s\n", readBuff);
      if ((readBuff[0] == '#') && (readBuff[1] == 'F') &&
          (readBuff[2] == 'I') && (readBuff[3] == 'N')) {
        data[991] = '\0';
        printf("DATA :: %s\n", data);
        fprintf(myFile, "---Tranfer completed\n");
        fprintf(myFile, "%s\n", data);
        break;
      }
      int s;
      int pos = 0;
      for (s = index; s < index + 4; s++) {
        data[s] = readBuff[pos];
        pos++;
      }
      fprintf(myFile, "|SEQ :: INDEX :: DATA|\n");
      fprintf(myFile, "|%d :: %d :: %s|\n", seq, index, readBuff);
      fprintf(myFile, "--------------------\n");
      fflush(myFile);
    } else if (conBuff[8] == '3') {
      unsigned char seqHex[] = {conBuff[0], conBuff[1], conBuff[2], conBuff[3],
                                '\0'};
      int seq;
      seq = (int)strtol(seqHex, NULL, 16);
      printf("seq num :: %d\n", seq);
      unsigned char indexHex[] = {conBuff[4], conBuff[5], conBuff[6],
                                  conBuff[7], '\0'};
      int index;
      index = (int)strtol(indexHex, NULL, 16);
      printf("index num :: %d\n", index);
      read(pipe3[0], &readBuff, 4);
      readBuff[4] = '\0';
      printf("Pipe 3 ->> %s\n", readBuff);
      if ((readBuff[0] == '#') && (readBuff[1] == 'F') &&
          (readBuff[2] == 'I') && (readBuff[3] == 'N')) {
        data[991] = '\0';
        printf("DATA :: %s\n", data);
        fprintf(myFile, "---Tranfer completed\n");
        fprintf(myFile, "%s\n", data);
        break;
      }
      int s;
      int pos = 0;
      for (s = index; s < index + 4; s++) {
        data[s] = readBuff[pos];
        pos++;
      }
      fprintf(myFile, "|SEQ :: INDEX :: DATA|\n");
      fprintf(myFile, "|%d :: %d :: %s|\n", seq, index, readBuff);
      fprintf(myFile, "--------------------\n");
      fflush(myFile);
    }
  }
  fclose(myFile);
}


x86 assembly (clang, -O0):
<dataParser>:
push   %rbp
mov    %rsp,%rbp
sub    $0x480,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
lea    -0x400(%rbp),%rdi
mov    $0x3df,%esi
call   10a0 <bzero@plt>
movb   $0x0,-0x21(%rbp)
lea    0xe4a(%rip),%rdi
lea    0xe52(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x408(%rbp)
mov    -0x408(%rbp),%rdi
lea    0xe3a(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
lea    0xe47(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%edi
lea    -0x412(%rbp),%rsi
mov    $0x9,%edx
mov    $0x0,%al
call   1050 <read@plt>
movb   $0x0,-0x409(%rbp)
lea    -0x412(%rbp),%rsi
lea    0xe28(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x408(%rbp),%rdi
lea    -0x412(%rbp),%rdx
lea    0xe17(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
call   1080 <fflush@plt>
movzbl -0x40a(%rbp),%eax
cmp    $0x31,%eax
jne    14b5 <dataParser+0x335>
mov    -0x412(%rbp),%al
mov    %al,-0x41b(%rbp)
mov    -0x411(%rbp),%al
mov    %al,-0x41a(%rbp)
mov    -0x410(%rbp),%al
mov    %al,-0x419(%rbp)
mov    -0x40f(%rbp),%al
mov    %al,-0x418(%rbp)
movb   $0x0,-0x417(%rbp)
lea    -0x41b(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0x10,%edx
call   1070 <strtol@plt>
mov    %eax,-0x420(%rbp)
mov    -0x420(%rbp),%esi
lea    0xda0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x40e(%rbp),%al
mov    %al,-0x425(%rbp)
mov    -0x40d(%rbp),%al
mov    %al,-0x424(%rbp)
mov    -0x40c(%rbp),%al
mov    %al,-0x423(%rbp)
mov    -0x40b(%rbp),%al
mov    %al,-0x422(%rbp)
movb   $0x0,-0x421(%rbp)
lea    -0x425(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0x10,%edx
call   1070 <strtol@plt>
mov    %eax,-0x42c(%rbp)
mov    -0x42c(%rbp),%esi
lea    0xd49(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
lea    -0x416(%rbp),%rsi
mov    $0x4,%edx
mov    $0x0,%al
call   1050 <read@plt>
movb   $0x0,-0x412(%rbp)
lea    -0x416(%rbp),%rsi
lea    0xd25(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsbl -0x416(%rbp),%eax
cmp    $0x23,%eax
jne    13e6 <dataParser+0x266>
movsbl -0x415(%rbp),%eax
cmp    $0x46,%eax
jne    13e6 <dataParser+0x266>
movsbl -0x414(%rbp),%eax
cmp    $0x49,%eax
jne    13e6 <dataParser+0x266>
movsbl -0x413(%rbp),%eax
cmp    $0x4e,%eax
jne    13e6 <dataParser+0x266>
movb   $0x0,-0x21(%rbp)
lea    -0x400(%rbp),%rsi
lea    0xcdb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x408(%rbp),%rdi
lea    0xcd2(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
lea    -0x400(%rbp),%rdx
lea    0xc6c(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    199d <dataParser+0x81d>
movl   $0x0,-0x434(%rbp)
mov    -0x42c(%rbp),%eax
mov    %eax,-0x430(%rbp)
mov    -0x430(%rbp),%eax
mov    -0x42c(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1452 <dataParser+0x2d2>
movslq -0x434(%rbp),%rax
mov    -0x416(%rbp,%rax,1),%cl
movslq -0x430(%rbp),%rax
mov    %cl,-0x400(%rbp,%rax,1)
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
mov    -0x430(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x430(%rbp)
jmp    13fc <dataParser+0x27c>
mov    -0x408(%rbp),%rdi
lea    0xc46(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
mov    -0x420(%rbp),%edx
mov    -0x42c(%rbp),%ecx
lea    -0x416(%rbp),%r8
lea    0xc36(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
lea    0xc33(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
call   1080 <fflush@plt>
jmp    1998 <dataParser+0x818>
movzbl -0x40a(%rbp),%eax
cmp    $0x32,%eax
jne    1724 <dataParser+0x5a4>
mov    -0x412(%rbp),%al
mov    %al,-0x439(%rbp)
mov    -0x411(%rbp),%al
mov    %al,-0x438(%rbp)
mov    -0x410(%rbp),%al
mov    %al,-0x437(%rbp)
mov    -0x40f(%rbp),%al
mov    %al,-0x436(%rbp)
movb   $0x0,-0x435(%rbp)
lea    -0x439(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0x10,%edx
call   1070 <strtol@plt>
mov    %eax,-0x440(%rbp)
mov    -0x440(%rbp),%esi
lea    0xb31(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x40e(%rbp),%al
mov    %al,-0x445(%rbp)
mov    -0x40d(%rbp),%al
mov    %al,-0x444(%rbp)
mov    -0x40c(%rbp),%al
mov    %al,-0x443(%rbp)
mov    -0x40b(%rbp),%al
mov    %al,-0x442(%rbp)
movb   $0x0,-0x441(%rbp)
lea    -0x445(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0x10,%edx
call   1070 <strtol@plt>
mov    %eax,-0x44c(%rbp)
mov    -0x44c(%rbp),%esi
lea    0xada(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%edi
lea    -0x416(%rbp),%rsi
mov    $0x4,%edx
mov    $0x0,%al
call   1050 <read@plt>
movb   $0x0,-0x412(%rbp)
lea    -0x416(%rbp),%rsi
lea    0xb27(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsbl -0x416(%rbp),%eax
cmp    $0x23,%eax
jne    1655 <dataParser+0x4d5>
movsbl -0x415(%rbp),%eax
cmp    $0x46,%eax
jne    1655 <dataParser+0x4d5>
movsbl -0x414(%rbp),%eax
cmp    $0x49,%eax
jne    1655 <dataParser+0x4d5>
movsbl -0x413(%rbp),%eax
cmp    $0x4e,%eax
jne    1655 <dataParser+0x4d5>
movb   $0x0,-0x21(%rbp)
lea    -0x400(%rbp),%rsi
lea    0xa6c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x408(%rbp),%rdi
lea    0xa63(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
lea    -0x400(%rbp),%rdx
lea    0x9fd(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    199d <dataParser+0x81d>
movl   $0x0,-0x454(%rbp)
mov    -0x44c(%rbp),%eax
mov    %eax,-0x450(%rbp)
mov    -0x450(%rbp),%eax
mov    -0x44c(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    16c1 <dataParser+0x541>
movslq -0x454(%rbp),%rax
mov    -0x416(%rbp,%rax,1),%cl
movslq -0x450(%rbp),%rax
mov    %cl,-0x400(%rbp,%rax,1)
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
mov    -0x450(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x450(%rbp)
jmp    166b <dataParser+0x4eb>
mov    -0x408(%rbp),%rdi
lea    0x9d7(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
mov    -0x440(%rbp),%edx
mov    -0x44c(%rbp),%ecx
lea    -0x416(%rbp),%r8
lea    0x9c7(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
lea    0x9c4(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
call   1080 <fflush@plt>
jmp    1993 <dataParser+0x813>
movzbl -0x40a(%rbp),%eax
cmp    $0x33,%eax
jne    198e <dataParser+0x80e>
mov    -0x412(%rbp),%al
mov    %al,-0x459(%rbp)
mov    -0x411(%rbp),%al
mov    %al,-0x458(%rbp)
mov    -0x410(%rbp),%al
mov    %al,-0x457(%rbp)
mov    -0x40f(%rbp),%al
mov    %al,-0x456(%rbp)
movb   $0x0,-0x455(%rbp)
lea    -0x459(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0x10,%edx
call   1070 <strtol@plt>
mov    %eax,-0x460(%rbp)
mov    -0x460(%rbp),%esi
lea    0x8c2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x40e(%rbp),%al
mov    %al,-0x465(%rbp)
mov    -0x40d(%rbp),%al
mov    %al,-0x464(%rbp)
mov    -0x40c(%rbp),%al
mov    %al,-0x463(%rbp)
mov    -0x40b(%rbp),%al
mov    %al,-0x462(%rbp)
movb   $0x0,-0x461(%rbp)
lea    -0x465(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0x10,%edx
call   1070 <strtol@plt>
mov    %eax,-0x46c(%rbp)
mov    -0x46c(%rbp),%esi
lea    0x86b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%edi
lea    -0x416(%rbp),%rsi
mov    $0x4,%edx
mov    $0x0,%al
call   1050 <read@plt>
movb   $0x0,-0x412(%rbp)
lea    -0x416(%rbp),%rsi
lea    0x8c7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsbl -0x416(%rbp),%eax
cmp    $0x23,%eax
jne    18c4 <dataParser+0x744>
movsbl -0x415(%rbp),%eax
cmp    $0x46,%eax
jne    18c4 <dataParser+0x744>
movsbl -0x414(%rbp),%eax
cmp    $0x49,%eax
jne    18c4 <dataParser+0x744>
movsbl -0x413(%rbp),%eax
cmp    $0x4e,%eax
jne    18c4 <dataParser+0x744>
movb   $0x0,-0x21(%rbp)
lea    -0x400(%rbp),%rsi
lea    0x7fd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x408(%rbp),%rdi
lea    0x7f4(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
lea    -0x400(%rbp),%rdx
lea    0x78e(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
jmp    199d <dataParser+0x81d>
movl   $0x0,-0x474(%rbp)
mov    -0x46c(%rbp),%eax
mov    %eax,-0x470(%rbp)
mov    -0x470(%rbp),%eax
mov    -0x46c(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1930 <dataParser+0x7b0>
movslq -0x474(%rbp),%rax
mov    -0x416(%rbp,%rax,1),%cl
movslq -0x470(%rbp),%rax
mov    %cl,-0x400(%rbp,%rax,1)
mov    -0x474(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x474(%rbp)
mov    -0x470(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x470(%rbp)
jmp    18da <dataParser+0x75a>
mov    -0x408(%rbp),%rdi
lea    0x768(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
mov    -0x460(%rbp),%edx
mov    -0x46c(%rbp),%ecx
lea    -0x416(%rbp),%r8
lea    0x758(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
lea    0x755(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x408(%rbp),%rdi
call   1080 <fflush@plt>
jmp    1993 <dataParser+0x813>
jmp    1998 <dataParser+0x818>
jmp    11ec <dataParser+0x6c>
mov    -0x408(%rbp),%rdi
call   1030 <fclose@plt>
add    $0x480,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dataParser>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x428,%rsp
mov    %ecx,%r14d
mov    %rdx,0x38(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rdi,0x28(%rsp)
lea    0x40(%rsp),%rdi
mov    $0x3df,%esi
call   10c0 <bzero@plt>
movb   $0x0,0x41f(%rsp)
lea    0xe0f(%rip),%rdi
lea    0xe17(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,%r13
lea    0xe0a(%rip),%rdi
mov    $0x1a,%esi
mov    $0x1,%edx
mov    %rax,%rcx
call   10d0 <fwrite@plt>
lea    0xed1(%rip),%rdi
call   1030 <puts@plt>
lea    0x1e(%rsp),%r12
lea    0x18(%rsp),%r15
nop
mov    %r14d,%edi
mov    %r12,%rsi
mov    $0x9,%edx
xor    %eax,%eax
call   1060 <read@plt>
movb   $0x0,0x27(%rsp)
lea    0xdde(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r13,%rdi
lea    0xdd5(%rip),%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    %r13,%rdi
call   10a0 <fflush@plt>
movzbl 0x26(%rsp),%eax
cmp    $0x33,%al
je     1320 <dataParser+0x170>
cmp    $0x32,%al
je     1450 <dataParser+0x2a0>
cmp    $0x31,%al
jne    1230 <dataParser+0x80>
mov    0x1e(%rsp),%eax
mov    %eax,0x13(%rsp)
movb   $0x0,0x17(%rsp)
lea    0x13(%rsp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1080 <strtol@plt>
mov    %rax,%rbp
lea    0xd8d(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x22(%rsp),%eax
mov    %eax,0xe(%rsp)
movb   $0x0,0x12(%rsp)
lea    0xe(%rsp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1080 <strtol@plt>
mov    %rax,%rbx
lea    0xd6b(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x28(%rsp),%rax
mov    (%rax),%edi
mov    %r15,%rsi
mov    $0x4,%edx
xor    %eax,%eax
call   1060 <read@plt>
movb   $0x0,0x1c(%rsp)
lea    0xd51(%rip),%rdi
jmp    14d4 <dataParser+0x324>
cs nopw 0x0(%rax,%rax,1)
mov    %r14d,%ebp
mov    0x1e(%rsp),%eax
mov    %eax,0x13(%rsp)
movb   $0x0,0x17(%rsp)
lea    0x13(%rsp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1080 <strtol@plt>
mov    %rax,%r14
lea    0xcf7(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x22(%rsp),%eax
mov    %eax,0xe(%rsp)
movb   $0x0,0x12(%rsp)
lea    0xe(%rsp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1080 <strtol@plt>
mov    %rax,%rbx
lea    0xcd4(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x38(%rsp),%rax
mov    (%rax),%edi
mov    %r15,%rsi
mov    $0x4,%edx
xor    %eax,%eax
call   1060 <read@plt>
movb   $0x0,0x1c(%rsp)
lea    0xd3a(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
movd   0x18(%rsp),%xmm0
movd   %xmm0,%eax
cmp    $0x4e494623,%eax
je     1567 <dataParser+0x3b7>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x3(%rbx),%edx
cmp    %ebx,%edx
cmovle %ebx,%edx
sub    %ebx,%edx
add    $0x1,%rdx
mov    %r15,%rsi
call   1090 <memcpy@plt>
mov    $0x17,%esi
mov    $0x1,%edx
lea    0xc9a(%rip),%rdi
mov    %r13,%rcx
call   10d0 <fwrite@plt>
mov    %r13,%rdi
lea    0xca0(%rip),%rsi
mov    %r14d,%edx
mov    %ebx,%ecx
mov    %r15,%r8
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    $0x15,%esi
mov    $0x1,%edx
lea    0xc92(%rip),%rdi
mov    %r13,%rcx
call   10d0 <fwrite@plt>
mov    %r13,%rdi
call   10a0 <fflush@plt>
mov    %ebp,%r14d
jmp    1230 <dataParser+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x1e(%rsp),%eax
mov    %eax,0x13(%rsp)
movb   $0x0,0x17(%rsp)
lea    0x13(%rsp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1080 <strtol@plt>
mov    %rax,%rbp
lea    0xbca(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x22(%rsp),%eax
mov    %eax,0xe(%rsp)
movb   $0x0,0x12(%rsp)
lea    0xe(%rsp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1080 <strtol@plt>
mov    %rax,%rbx
lea    0xba8(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x30(%rsp),%rax
mov    (%rax),%edi
mov    %r15,%rsi
mov    $0x4,%edx
xor    %eax,%eax
call   1060 <read@plt>
movb   $0x0,0x1c(%rsp)
lea    0xbff(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
movd   0x18(%rsp),%xmm0
movd   %xmm0,%eax
cmp    $0x4e494623,%eax
je     1567 <dataParser+0x3b7>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
lea    0x3(%rbx),%edx
cmp    %ebx,%edx
cmovle %ebx,%edx
sub    %ebx,%edx
add    $0x1,%rdx
mov    %r15,%rsi
call   1090 <memcpy@plt>
mov    $0x17,%esi
mov    $0x1,%edx
lea    0xb72(%rip),%rdi
mov    %r13,%rcx
call   10d0 <fwrite@plt>
mov    %r13,%rdi
lea    0xb78(%rip),%rsi
mov    %ebp,%edx
mov    %ebx,%ecx
mov    %r15,%r8
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    $0x15,%esi
mov    $0x1,%edx
lea    0xb6b(%rip),%rdi
mov    %r13,%rcx
call   10d0 <fwrite@plt>
mov    %r13,%rdi
call   10a0 <fflush@plt>
jmp    1230 <dataParser+0x80>
movb   $0x0,0x41f(%rsp)
lea    0xafb(%rip),%rdi
lea    0x40(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xaf1(%rip),%rdi
mov    $0x15,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   10d0 <fwrite@plt>
lea    0xa8e(%rip),%rsi
mov    %r13,%rdi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    %r13,%rdi
call   1040 <fclose@plt>
add    $0x428,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [15 x i8] c"./Sresults.txt\00"
@.str.1 = [2 x i8] c"a\00"
@.str.2 = [27 x i8] c"Starting MP TCP :: Server\0A\00"
@.str.3 = [19 x i8] c"Control:: Reading\0A\00"
@.str.4 = [11 x i8] c"inc-> %s\0A\00"
@.str.5 = [11 x i8] c"DSS :: %s\0A\00"
@.str.6 = [15 x i8] c"seq num :: %d\0A\00"
@.str.7 = [17 x i8] c"index num :: %d\0A\00"
@.str.8 = [15 x i8] c"Pipe 1 ->> %s\0A\00"
@.str.9 = [12 x i8] c"DATA :: %s\0A\00"
@.str.10 = [22 x i8] c"---Tranfer completed\0A\00"
@.str.11 = [4 x i8] c"%s\0A\00"
@.str.12 = [24 x i8] c"|SEQ :: INDEX :: DATA|\0A\00"
@.str.13 = [18 x i8] c"|%d :: %d :: %s|\0A\00"
@.str.14 = [22 x i8] c"--------------------\0A\00"
@.str.15 = [15 x i8] c"Pipe 2 ->> %s\0A\00"
@.str.16 = [15 x i8] c"Pipe 3 ->> %s\0A\00"
define void @dataParser(i32* %0, i32* %1, i32* %2, i32 %3) {
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca [991 x i8]
%10 = alloca i32*
%11 = alloca [10 x i8]
%12 = alloca [4 x i8]
%13 = alloca [5 x i8]
%14 = alloca i32
%15 = alloca [5 x i8]
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca [5 x i8]
%20 = alloca i32
%21 = alloca [5 x i8]
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca [5 x i8]
%26 = alloca i32
%27 = alloca [5 x i8]
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store i32* %0, i32** %5
store i32* %1, i32** %6
store i32* %2, i32** %7
store i32 %3, i32* %8
%31 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 0
%32 = call i32 @bzero(i8* %31, i32 991)
%33 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 991
store i8 0, i8* %33
%34 = call i32* @fopen(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %34, i32** %10
%35 = load i32*, i32** %10
%36 = call i32 (i32*, i8*, ...) @fprintf(i32* %35, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0))
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.3, i64 0, i64 0))
br label %38
38: ; preds = %4, %377
%39 = load i32, i32* %8
%40 = call i32 (i32, ...) @read(i32 %39, [10 x i8]* %11, i32 9)
%41 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 9
store i8 0, i8* %41
%42 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 0
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0), i8* %42)
%44 = load i32*, i32** %10
%45 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 0
%46 = call i32 (i32*, i8*, ...) @fprintf(i32* %44, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0), i8* %45)
%47 = load i32*, i32** %10
%48 = call i32 @fflush(i32* %47)
%49 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 8
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = icmp eq i32 %51, 49
br i1 %52, label %53, label %157
53: ; preds = %38
%54 = getelementptr inbounds [5 x i8], [5 x i8]* %13, i64 0, i64 0
%55 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 0
%56 = load i8, i8* %55
store i8 %56, i8* %54
%57 = getelementptr inbounds i8, i8* %54, i64 1
%58 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 1
%59 = load i8, i8* %58
store i8 %59, i8* %57
%60 = getelementptr inbounds i8, i8* %57, i64 1
%61 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 2
%62 = load i8, i8* %61
store i8 %62, i8* %60
%63 = getelementptr inbounds i8, i8* %60, i64 1
%64 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 3
%65 = load i8, i8* %64
store i8 %65, i8* %63
%66 = getelementptr inbounds i8, i8* %63, i64 1
store i8 0, i8* %66
%67 = getelementptr inbounds [5 x i8], [5 x i8]* %13, i64 0, i64 0
%68 = call i64 @strtol(i8* %67, i32* null, i32 16)
%69 = trunc i64 %68 to i32
store i32 %69, i32* %14
%70 = load i32, i32* %14
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), i32 %70)
%72 = getelementptr inbounds [5 x i8], [5 x i8]* %15, i64 0, i64 0
%73 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 4
%74 = load i8, i8* %73
store i8 %74, i8* %72
%75 = getelementptr inbounds i8, i8* %72, i64 1
%76 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 5
%77 = load i8, i8* %76
store i8 %77, i8* %75
%78 = getelementptr inbounds i8, i8* %75, i64 1
%79 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 6
%80 = load i8, i8* %79
store i8 %80, i8* %78
%81 = getelementptr inbounds i8, i8* %78, i64 1
%82 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 7
%83 = load i8, i8* %82
store i8 %83, i8* %81
%84 = getelementptr inbounds i8, i8* %81, i64 1
store i8 0, i8* %84
%85 = getelementptr inbounds [5 x i8], [5 x i8]* %15, i64 0, i64 0
%86 = call i64 @strtol(i8* %85, i32* null, i32 16)
%87 = trunc i64 %86 to i32
store i32 %87, i32* %16
%88 = load i32, i32* %16
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), i32 %88)
%90 = load i32*, i32** %5
%91 = getelementptr inbounds i32, i32* %90, i64 0
%92 = load i32, i32* %91
%93 = call i32 (i32, ...) @read(i32 %92, [4 x i8]* %12, i32 4)
%94 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 4
store i8 0, i8* %94
%95 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), i8* %95)
%97 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
%100 = icmp eq i32 %99, 35
br i1 %100, label %101, label %125
101: ; preds = %53
%102 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 1
%103 = load i8, i8* %102
%104 = sext i8 %103 to i32
%105 = icmp eq i32 %104, 70
br i1 %105, label %106, label %125
106: ; preds = %101
%107 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 2
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = icmp eq i32 %109, 73
br i1 %110, label %111, label %125
111: ; preds = %106
%112 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 3
%113 = load i8, i8* %112
%114 = sext i8 %113 to i32
%115 = icmp eq i32 %114, 78
br i1 %115, label %116, label %125
116: ; preds = %111
%117 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 991
store i8 0, i8* %117
%118 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 0
%119 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0), i8* %118)
%120 = load i32*, i32** %10
%121 = call i32 (i32*, i8*, ...) @fprintf(i32* %120, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0))
%122 = load i32*, i32** %10
%123 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 0
%124 = call i32 (i32*, i8*, ...) @fprintf(i32* %122, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %123)
br label %378
125: ; preds = %111, %106, %101, %53
store i32 0, i32* %18
%126 = load i32, i32* %16
store i32 %126, i32* %17
br label %127
127: ; preds = %142, %125
%128 = load i32, i32* %17
%129 = load i32, i32* %16
%130 = add nsw i32 %129, 4
%131 = icmp slt i32 %128, %130
br i1 %131, label %132, label %145
132: ; preds = %127
%133 = load i32, i32* %18
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 %134
%136 = load i8, i8* %135
%137 = load i32, i32* %17
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 %138
store i8 %136, i8* %139
%140 = load i32, i32* %18
%141 = add nsw i32 %140, 1
store i32 %141, i32* %18
br label %142
142: ; preds = %132
%143 = load i32, i32* %17
%144 = add nsw i32 %143, 1
store i32 %144, i32* %17
br label %127
145: ; preds = %127
%146 = load i32*, i32** %10
%147 = call i32 (i32*, i8*, ...) @fprintf(i32* %146, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.12, i64 0, i64 0))
%148 = load i32*, i32** %10
%149 = load i32, i32* %14
%150 = load i32, i32* %16
%151 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%152 = call i32 (i32*, i8*, ...) @fprintf(i32* %148, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0), i32 %149, i32 %150, i8* %151)
%153 = load i32*, i32** %10
%154 = call i32 (i32*, i8*, ...) @fprintf(i32* %153, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0))
%155 = load i32*, i32** %10
%156 = call i32 @fflush(i32* %155)
br label %377
157: ; preds = %38
%158 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 8
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
%161 = icmp eq i32 %160, 50
br i1 %161, label %162, label %266
162: ; preds = %157
%163 = getelementptr inbounds [5 x i8], [5 x i8]* %19, i64 0, i64 0
%164 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 0
%165 = load i8, i8* %164
store i8 %165, i8* %163
%166 = getelementptr inbounds i8, i8* %163, i64 1
%167 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 1
%168 = load i8, i8* %167
store i8 %168, i8* %166
%169 = getelementptr inbounds i8, i8* %166, i64 1
%170 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 2
%171 = load i8, i8* %170
store i8 %171, i8* %169
%172 = getelementptr inbounds i8, i8* %169, i64 1
%173 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 3
%174 = load i8, i8* %173
store i8 %174, i8* %172
%175 = getelementptr inbounds i8, i8* %172, i64 1
store i8 0, i8* %175
%176 = getelementptr inbounds [5 x i8], [5 x i8]* %19, i64 0, i64 0
%177 = call i64 @strtol(i8* %176, i32* null, i32 16)
%178 = trunc i64 %177 to i32
store i32 %178, i32* %20
%179 = load i32, i32* %20
%180 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), i32 %179)
%181 = getelementptr inbounds [5 x i8], [5 x i8]* %21, i64 0, i64 0
%182 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 4
%183 = load i8, i8* %182
store i8 %183, i8* %181
%184 = getelementptr inbounds i8, i8* %181, i64 1
%185 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 5
%186 = load i8, i8* %185
store i8 %186, i8* %184
%187 = getelementptr inbounds i8, i8* %184, i64 1
%188 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 6
%189 = load i8, i8* %188
store i8 %189, i8* %187
%190 = getelementptr inbounds i8, i8* %187, i64 1
%191 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 7
%192 = load i8, i8* %191
store i8 %192, i8* %190
%193 = getelementptr inbounds i8, i8* %190, i64 1
store i8 0, i8* %193
%194 = getelementptr inbounds [5 x i8], [5 x i8]* %21, i64 0, i64 0
%195 = call i64 @strtol(i8* %194, i32* null, i32 16)
%196 = trunc i64 %195 to i32
store i32 %196, i32* %22
%197 = load i32, i32* %22
%198 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), i32 %197)
%199 = load i32*, i32** %6
%200 = getelementptr inbounds i32, i32* %199, i64 0
%201 = load i32, i32* %200
%202 = call i32 (i32, ...) @read(i32 %201, [4 x i8]* %12, i32 4)
%203 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 4
store i8 0, i8* %203
%204 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.15, i64 0, i64 0), i8* %204)
%206 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%207 = load i8, i8* %206
%208 = sext i8 %207 to i32
%209 = icmp eq i32 %208, 35
br i1 %209, label %210, label %234
210: ; preds = %162
%211 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 1
%212 = load i8, i8* %211
%213 = sext i8 %212 to i32
%214 = icmp eq i32 %213, 70
br i1 %214, label %215, label %234
215: ; preds = %210
%216 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 2
%217 = load i8, i8* %216
%218 = sext i8 %217 to i32
%219 = icmp eq i32 %218, 73
br i1 %219, label %220, label %234
220: ; preds = %215
%221 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 3
%222 = load i8, i8* %221
%223 = sext i8 %222 to i32
%224 = icmp eq i32 %223, 78
br i1 %224, label %225, label %234
225: ; preds = %220
%226 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 991
store i8 0, i8* %226
%227 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 0
%228 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0), i8* %227)
%229 = load i32*, i32** %10
%230 = call i32 (i32*, i8*, ...) @fprintf(i32* %229, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0))
%231 = load i32*, i32** %10
%232 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 0
%233 = call i32 (i32*, i8*, ...) @fprintf(i32* %231, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %232)
br label %378
234: ; preds = %220, %215, %210, %162
store i32 0, i32* %24
%235 = load i32, i32* %22
store i32 %235, i32* %23
br label %236
236: ; preds = %251, %234
%237 = load i32, i32* %23
%238 = load i32, i32* %22
%239 = add nsw i32 %238, 4
%240 = icmp slt i32 %237, %239
br i1 %240, label %241, label %254
241: ; preds = %236
%242 = load i32, i32* %24
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 %243
%245 = load i8, i8* %244
%246 = load i32, i32* %23
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 %247
store i8 %245, i8* %248
%249 = load i32, i32* %24
%250 = add nsw i32 %249, 1
store i32 %250, i32* %24
br label %251
251: ; preds = %241
%252 = load i32, i32* %23
%253 = add nsw i32 %252, 1
store i32 %253, i32* %23
br label %236
254: ; preds = %236
%255 = load i32*, i32** %10
%256 = call i32 (i32*, i8*, ...) @fprintf(i32* %255, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.12, i64 0, i64 0))
%257 = load i32*, i32** %10
%258 = load i32, i32* %20
%259 = load i32, i32* %22
%260 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%261 = call i32 (i32*, i8*, ...) @fprintf(i32* %257, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0), i32 %258, i32 %259, i8* %260)
%262 = load i32*, i32** %10
%263 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0))
%264 = load i32*, i32** %10
%265 = call i32 @fflush(i32* %264)
br label %376
266: ; preds = %157
%267 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 8
%268 = load i8, i8* %267
%269 = zext i8 %268 to i32
%270 = icmp eq i32 %269, 51
br i1 %270, label %271, label %375
271: ; preds = %266
%272 = getelementptr inbounds [5 x i8], [5 x i8]* %25, i64 0, i64 0
%273 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 0
%274 = load i8, i8* %273
store i8 %274, i8* %272
%275 = getelementptr inbounds i8, i8* %272, i64 1
%276 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 1
%277 = load i8, i8* %276
store i8 %277, i8* %275
%278 = getelementptr inbounds i8, i8* %275, i64 1
%279 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 2
%280 = load i8, i8* %279
store i8 %280, i8* %278
%281 = getelementptr inbounds i8, i8* %278, i64 1
%282 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 3
%283 = load i8, i8* %282
store i8 %283, i8* %281
%284 = getelementptr inbounds i8, i8* %281, i64 1
store i8 0, i8* %284
%285 = getelementptr inbounds [5 x i8], [5 x i8]* %25, i64 0, i64 0
%286 = call i64 @strtol(i8* %285, i32* null, i32 16)
%287 = trunc i64 %286 to i32
store i32 %287, i32* %26
%288 = load i32, i32* %26
%289 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), i32 %288)
%290 = getelementptr inbounds [5 x i8], [5 x i8]* %27, i64 0, i64 0
%291 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 4
%292 = load i8, i8* %291
store i8 %292, i8* %290
%293 = getelementptr inbounds i8, i8* %290, i64 1
%294 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 5
%295 = load i8, i8* %294
store i8 %295, i8* %293
%296 = getelementptr inbounds i8, i8* %293, i64 1
%297 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 6
%298 = load i8, i8* %297
store i8 %298, i8* %296
%299 = getelementptr inbounds i8, i8* %296, i64 1
%300 = getelementptr inbounds [10 x i8], [10 x i8]* %11, i64 0, i64 7
%301 = load i8, i8* %300
store i8 %301, i8* %299
%302 = getelementptr inbounds i8, i8* %299, i64 1
store i8 0, i8* %302
%303 = getelementptr inbounds [5 x i8], [5 x i8]* %27, i64 0, i64 0
%304 = call i64 @strtol(i8* %303, i32* null, i32 16)
%305 = trunc i64 %304 to i32
store i32 %305, i32* %28
%306 = load i32, i32* %28
%307 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), i32 %306)
%308 = load i32*, i32** %7
%309 = getelementptr inbounds i32, i32* %308, i64 0
%310 = load i32, i32* %309
%311 = call i32 (i32, ...) @read(i32 %310, [4 x i8]* %12, i32 4)
%312 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 4
store i8 0, i8* %312
%313 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%314 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.16, i64 0, i64 0), i8* %313)
%315 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%316 = load i8, i8* %315
%317 = sext i8 %316 to i32
%318 = icmp eq i32 %317, 35
br i1 %318, label %319, label %343
319: ; preds = %271
%320 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 1
%321 = load i8, i8* %320
%322 = sext i8 %321 to i32
%323 = icmp eq i32 %322, 70
br i1 %323, label %324, label %343
324: ; preds = %319
%325 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 2
%326 = load i8, i8* %325
%327 = sext i8 %326 to i32
%328 = icmp eq i32 %327, 73
br i1 %328, label %329, label %343
329: ; preds = %324
%330 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 3
%331 = load i8, i8* %330
%332 = sext i8 %331 to i32
%333 = icmp eq i32 %332, 78
br i1 %333, label %334, label %343
334: ; preds = %329
%335 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 991
store i8 0, i8* %335
%336 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 0
%337 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0), i8* %336)
%338 = load i32*, i32** %10
%339 = call i32 (i32*, i8*, ...) @fprintf(i32* %338, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0))
%340 = load i32*, i32** %10
%341 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 0
%342 = call i32 (i32*, i8*, ...) @fprintf(i32* %340, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %341)
br label %378
343: ; preds = %329, %324, %319, %271
store i32 0, i32* %30
%344 = load i32, i32* %28
store i32 %344, i32* %29
br label %345
345: ; preds = %360, %343
%346 = load i32, i32* %29
%347 = load i32, i32* %28
%348 = add nsw i32 %347, 4
%349 = icmp slt i32 %346, %348
br i1 %349, label %350, label %363
350: ; preds = %345
%351 = load i32, i32* %30
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 %352
%354 = load i8, i8* %353
%355 = load i32, i32* %29
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds [991 x i8], [991 x i8]* %9, i64 0, i64 %356
store i8 %354, i8* %357
%358 = load i32, i32* %30
%359 = add nsw i32 %358, 1
store i32 %359, i32* %30
br label %360
360: ; preds = %350
%361 = load i32, i32* %29
%362 = add nsw i32 %361, 1
store i32 %362, i32* %29
br label %345
363: ; preds = %345
%364 = load i32*, i32** %10
%365 = call i32 (i32*, i8*, ...) @fprintf(i32* %364, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.12, i64 0, i64 0))
%366 = load i32*, i32** %10
%367 = load i32, i32* %26
%368 = load i32, i32* %28
%369 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%370 = call i32 (i32*, i8*, ...) @fprintf(i32* %366, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0), i32 %367, i32 %368, i8* %369)
%371 = load i32*, i32** %10
%372 = call i32 (i32*, i8*, ...) @fprintf(i32* %371, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0))
%373 = load i32*, i32** %10
%374 = call i32 @fflush(i32* %373)
br label %375
375: ; preds = %363, %266
br label %376
376: ; preds = %375, %254
br label %377
377: ; preds = %376, %145
br label %38
378: ; preds = %334, %225, %116
%379 = load i32*, i32** %10
%380 = call i32 @fclose(i32* %379)
ret void
}

LLVM IR (-O2):
@.str = [15 x i8] c"./Sresults.txt\00"
@.str.1 = [2 x i8] c"a\00"
@.str.2 = [27 x i8] c"Starting MP TCP :: Server\0A\00"
@.str.4 = [11 x i8] c"inc-> %s\0A\00"
@.str.5 = [11 x i8] c"DSS :: %s\0A\00"
@.str.6 = [15 x i8] c"seq num :: %d\0A\00"
@.str.7 = [17 x i8] c"index num :: %d\0A\00"
@.str.8 = [15 x i8] c"Pipe 1 ->> %s\0A\00"
@.str.9 = [12 x i8] c"DATA :: %s\0A\00"
@.str.10 = [22 x i8] c"---Tranfer completed\0A\00"
@.str.11 = [4 x i8] c"%s\0A\00"
@.str.12 = [24 x i8] c"|SEQ :: INDEX :: DATA|\0A\00"
@.str.13 = [18 x i8] c"|%d :: %d :: %s|\0A\00"
@.str.14 = [22 x i8] c"--------------------\0A\00"
@.str.15 = [15 x i8] c"Pipe 2 ->> %s\0A\00"
@.str.16 = [15 x i8] c"Pipe 3 ->> %s\0A\00"
@str = [18 x i8] c"Control:: Reading\00"
define void @dataParser(i32* nocapture %0, i32* nocapture %1, i32* nocapture %2, i32 %3) {
%5 = alloca [991 x i8]
%6 = alloca [10 x i8]
%7 = alloca <4 x i8>
%8 = getelementptr inbounds <4 x i8>, <4 x i8>* %7, i64 0, i64 0
%9 = alloca [5 x i8]
%10 = alloca [5 x i8]
%11 = alloca [5 x i8]
%12 = alloca [5 x i8]
%13 = alloca [5 x i8]
%14 = alloca [5 x i8]
%15 = getelementptr inbounds [991 x i8], [991 x i8]* %5, i64 0, i64 0
%16 = call i32 @bzero(i8* %15, i32 991)
%17 = getelementptr inbounds [991 x i8], [991 x i8]* %5, i64 0, i64 991
store i8 0, i8* %17
%18 = tail call i32* @fopen(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%19 = tail call i64 @fwrite(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), i64 26, i64 1, i32* %18)
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
%21 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 0
%22 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 9
%23 = getelementptr inbounds <4 x i8>, <4 x i8>* %7, i64 0, i64 0
%24 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 8
%25 = getelementptr inbounds [5 x i8], [5 x i8]* %13, i64 0, i64 0
%26 = getelementptr inbounds [5 x i8], [5 x i8]* %13, i64 0, i64 1
%27 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 1
%28 = getelementptr inbounds [5 x i8], [5 x i8]* %13, i64 0, i64 2
%29 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 2
%30 = getelementptr inbounds [5 x i8], [5 x i8]* %13, i64 0, i64 3
%31 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 3
%32 = getelementptr inbounds [5 x i8], [5 x i8]* %13, i64 0, i64 4
%33 = getelementptr inbounds [5 x i8], [5 x i8]* %14, i64 0, i64 0
%34 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 4
%35 = getelementptr inbounds [5 x i8], [5 x i8]* %14, i64 0, i64 1
%36 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 5
%37 = getelementptr inbounds [5 x i8], [5 x i8]* %14, i64 0, i64 2
%38 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 6
%39 = getelementptr inbounds [5 x i8], [5 x i8]* %14, i64 0, i64 3
%40 = getelementptr inbounds [10 x i8], [10 x i8]* %6, i64 0, i64 7
%41 = getelementptr inbounds [5 x i8], [5 x i8]* %14, i64 0, i64 4
%42 = getelementptr inbounds <4 x i8>, <4 x i8>* %7, i64 0, i64 4
%43 = getelementptr inbounds [5 x i8], [5 x i8]* %11, i64 0, i64 0
%44 = getelementptr inbounds [5 x i8], [5 x i8]* %11, i64 0, i64 1
%45 = getelementptr inbounds [5 x i8], [5 x i8]* %11, i64 0, i64 2
%46 = getelementptr inbounds [5 x i8], [5 x i8]* %11, i64 0, i64 3
%47 = getelementptr inbounds [5 x i8], [5 x i8]* %11, i64 0, i64 4
%48 = getelementptr inbounds [5 x i8], [5 x i8]* %12, i64 0, i64 0
%49 = getelementptr inbounds [5 x i8], [5 x i8]* %12, i64 0, i64 1
%50 = getelementptr inbounds [5 x i8], [5 x i8]* %12, i64 0, i64 2
%51 = getelementptr inbounds [5 x i8], [5 x i8]* %12, i64 0, i64 3
%52 = getelementptr inbounds [5 x i8], [5 x i8]* %12, i64 0, i64 4
%53 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 0
%54 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 1
%55 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 2
%56 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 3
%57 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 4
%58 = getelementptr inbounds [5 x i8], [5 x i8]* %10, i64 0, i64 0
%59 = getelementptr inbounds [5 x i8], [5 x i8]* %10, i64 0, i64 1
%60 = getelementptr inbounds [5 x i8], [5 x i8]* %10, i64 0, i64 2
%61 = getelementptr inbounds [5 x i8], [5 x i8]* %10, i64 0, i64 3
%62 = getelementptr inbounds [5 x i8], [5 x i8]* %10, i64 0, i64 4
br label %63
63: ; preds = %186, %4
%64 = call i32 (i32, ...) @read(i32 %3, [10 x i8]* %6, i32 9)
store i8 0, i8* %22
%65 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0), i8* %21)
%66 = call i32 (i32*, i8*, ...) @fprintf(i32* %18, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0), i8* %21)
%67 = call i32 @fflush(i32* %18)
%68 = load i8, i8* %24
switch i8 %68, label %186 [
i8 49, label %69
i8 50, label %108
i8 51, label %147
]
69: ; preds = %63
%70 = load i8, i8* %21
store i8 %70, i8* %53
%71 = load i8, i8* %27
store i8 %71, i8* %54
%72 = load i8, i8* %29
store i8 %72, i8* %55
%73 = load i8, i8* %31
store i8 %73, i8* %56
store i8 0, i8* %57
%74 = call i64 @strtol(i8* nocapture %53, i32* null, i32 16)
%75 = trunc i64 %74 to i32
%76 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), i32 %75)
%77 = load i8, i8* %34
store i8 %77, i8* %58
%78 = load i8, i8* %36
store i8 %78, i8* %59
%79 = load i8, i8* %38
store i8 %79, i8* %60
%80 = load i8, i8* %40
store i8 %80, i8* %61
store i8 0, i8* %62
%81 = call i64 @strtol(i8* nocapture %58, i32* null, i32 16)
%82 = trunc i64 %81 to i32
%83 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), i32 %82)
%84 = load i32, i32* %0
%85 = call i32 (i32, ...) @read(i32 %84, <4 x i8>* %7, i32 4)
store i8 0, i8* %42
%86 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0), i8* %23)
%87 = load <4 x i8>, <4 x i8>* %7
%88 = freeze <4 x i8> %87
%89 = bitcast <4 x i8> %88 to i32
%90 = icmp eq i32 %89, 1313424931
br i1 %90, label %104, label %91
91: ; preds = %69
%92 = shl i64 %81, 32
%93 = ashr exact i64 %92, 32
%94 = getelementptr [991 x i8], [991 x i8]* %5, i64 0, i64 %93
%95 = add i32 %82, 3
%96 = call i32 @llvm.smax.i32(i32 %95, i32 %82)
%97 = sub i32 %96, %82
%98 = zext i32 %97 to i64
%99 = add nuw nsw i64 %98, 1
%100 = call i64 @fwrite(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.12, i64 0, i64 0), i64 23, i64 1, i32* %18)
%101 = call i32 (i32*, i8*, ...) @fprintf(i32* %18, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0), i32 %75, i32 %82, i8* %23)
%102 = call i64 @fwrite(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0), i64 21, i64 1, i32* %18)
%103 = call i32 @fflush(i32* %18)
br label %186
104: ; preds = %69
store i8 0, i8* %17
%105 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0), i8* %15)
%106 = call i64 @fwrite(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0), i64 21, i64 1, i32* %18)
%107 = call i32 (i32*, i8*, ...) @fprintf(i32* %18, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %15)
br label %187
108: ; preds = %63
%109 = load i8, i8* %21
store i8 %109, i8* %43
%110 = load i8, i8* %27
store i8 %110, i8* %44
%111 = load i8, i8* %29
store i8 %111, i8* %45
%112 = load i8, i8* %31
store i8 %112, i8* %46
store i8 0, i8* %47
%113 = call i64 @strtol(i8* nocapture %43, i32* null, i32 16)
%114 = trunc i64 %113 to i32
%115 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), i32 %114)
%116 = load i8, i8* %34
store i8 %116, i8* %48
%117 = load i8, i8* %36
store i8 %117, i8* %49
%118 = load i8, i8* %38
store i8 %118, i8* %50
%119 = load i8, i8* %40
store i8 %119, i8* %51
store i8 0, i8* %52
%120 = call i64 @strtol(i8* nocapture %48, i32* null, i32 16)
%121 = trunc i64 %120 to i32
%122 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), i32 %121)
%123 = load i32, i32* %1
%124 = call i32 (i32, ...) @read(i32 %123, <4 x i8>* %7, i32 4)
store i8 0, i8* %42
%125 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.15, i64 0, i64 0), i8* %23)
%126 = load <4 x i8>, <4 x i8>* %7
%127 = freeze <4 x i8> %126
%128 = bitcast <4 x i8> %127 to i32
%129 = icmp eq i32 %128, 1313424931
br i1 %129, label %143, label %130
130: ; preds = %108
%131 = shl i64 %120, 32
%132 = ashr exact i64 %131, 32
%133 = getelementptr [991 x i8], [991 x i8]* %5, i64 0, i64 %132
%134 = add i32 %121, 3
%135 = call i32 @llvm.smax.i32(i32 %134, i32 %121)
%136 = sub i32 %135, %121
%137 = zext i32 %136 to i64
%138 = add nuw nsw i64 %137, 1
%139 = call i64 @fwrite(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.12, i64 0, i64 0), i64 23, i64 1, i32* %18)
%140 = call i32 (i32*, i8*, ...) @fprintf(i32* %18, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0), i32 %114, i32 %121, i8* %23)
%141 = call i64 @fwrite(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0), i64 21, i64 1, i32* %18)
%142 = call i32 @fflush(i32* %18)
br label %186
143: ; preds = %108
store i8 0, i8* %17
%144 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0), i8* %15)
%145 = call i64 @fwrite(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0), i64 21, i64 1, i32* %18)
%146 = call i32 (i32*, i8*, ...) @fprintf(i32* %18, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %15)
br label %187
147: ; preds = %63
%148 = load i8, i8* %21
store i8 %148, i8* %25
%149 = load i8, i8* %27
store i8 %149, i8* %26
%150 = load i8, i8* %29
store i8 %150, i8* %28
%151 = load i8, i8* %31
store i8 %151, i8* %30
store i8 0, i8* %32
%152 = call i64 @strtol(i8* nocapture %25, i32* null, i32 16)
%153 = trunc i64 %152 to i32
%154 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0), i32 %153)
%155 = load i8, i8* %34
store i8 %155, i8* %33
%156 = load i8, i8* %36
store i8 %156, i8* %35
%157 = load i8, i8* %38
store i8 %157, i8* %37
%158 = load i8, i8* %40
store i8 %158, i8* %39
store i8 0, i8* %41
%159 = call i64 @strtol(i8* nocapture %33, i32* null, i32 16)
%160 = trunc i64 %159 to i32
%161 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i64 0, i64 0), i32 %160)
%162 = load i32, i32* %2
%163 = call i32 (i32, ...) @read(i32 %162, <4 x i8>* %7, i32 4)
store i8 0, i8* %42
%164 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.16, i64 0, i64 0), i8* %23)
%165 = load <4 x i8>, <4 x i8>* %7
%166 = freeze <4 x i8> %165
%167 = bitcast <4 x i8> %166 to i32
%168 = icmp eq i32 %167, 1313424931
br i1 %168, label %182, label %169
169: ; preds = %147
%170 = shl i64 %159, 32
%171 = ashr exact i64 %170, 32
%172 = getelementptr [991 x i8], [991 x i8]* %5, i64 0, i64 %171
%173 = add i32 %160, 3
%174 = call i32 @llvm.smax.i32(i32 %173, i32 %160)
%175 = sub i32 %174, %160
%176 = zext i32 %175 to i64
%177 = add nuw nsw i64 %176, 1
%178 = call i64 @fwrite(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.12, i64 0, i64 0), i64 23, i64 1, i32* %18)
%179 = call i32 (i32*, i8*, ...) @fprintf(i32* %18, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.13, i64 0, i64 0), i32 %153, i32 %160, i8* %23)
%180 = call i64 @fwrite(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0), i64 21, i64 1, i32* %18)
%181 = call i32 @fflush(i32* %18)
br label %186
182: ; preds = %147
store i8 0, i8* %17
%183 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0), i8* %15)
%184 = call i64 @fwrite(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0), i64 21, i64 1, i32* %18)
%185 = call i32 (i32*, i8*, ...) @fprintf(i32* %18, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* %15)
br label %187
186: ; preds = %91, %130, %169, %63
br label %63
187: ; preds = %104, %143, %182
%188 = call i32 @fclose(i32* %18)
ret void
}