#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 */
struct timespec {
  int tv_nsec;
};
typedef int /*<<< orphan*/ sendBuf;

/* Variables and functions */
int /*<<< orphan*/ CLOCK_MONOTONIC;
int /*<<< orphan*/ EXIT_FAILURE;
int /*<<< orphan*/ TIMER_ABSTIME;
int /*<<< orphan*/ clock_gettime(int /*<<< orphan*/, struct timespec *);
int /*<<< orphan*/ clock_nanosleep(int /*<<< orphan*/, int /*<<< orphan*/,
                                   struct timespec *, int /*<<< orphan*/ *);
int decode(char *, char *);
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int getBinaryData(char *, int, int);
int /*<<< orphan*/ popElement1(char *);
int /*<<< orphan*/ pthread_exit(char *);
int pushElement2(char *);
int /*<<< orphan*/ snprintf(char *, int, char *, int /*<<< orphan*/, char *,
                            int, int, int, int, int, int, int, int);
int /*<<< orphan*/ stderr;
scalar_t__ strcmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
int /*<<< orphan*/ strlen(char *);
int /*<<< orphan*/ strncpy(char *, char *, int);
int /*<<< orphan*/ tnorm(struct timespec *);
int /*<<< orphan*/ write(int, char *, int /*<<< orphan*/);
void *msg_io(void *arg) {
  int cmd, i, j = 0, res, connfd;
  int *connfd_ptr;
  int data0, data1, data2, data3;
  int data4, data5, data6, data7;
  char msg[50] = "", oldPKMsg[50] = "", oldKPMsg[50] = "";
  char sendBuf[1024] = "";
  char word[(64)] = "", wordk[(64)] = "";
  long unsigned index = 0;
  struct timespec t;
  connfd_ptr = (int *)arg;
  connfd = *connfd_ptr;
  strncpy(wordk,
          "1111111111111111111111111111111111111111111111111111111111111111",
          (64));
  clock_gettime(CLOCK_MONOTONIC, &t);
  while (1) {
    t.tv_nsec += (5000000);
    ;
    tnorm(&t);
    clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &t, NULL);
    for (i = 0; i < (64); i++)
      popElement1(&word[i]);
    cmd = decode(word, msg);
    data0 = getBinaryData(word, 0, 8);
    data1 = getBinaryData(word, 8, 8);
    data2 = getBinaryData(word, 16, 8);
    data3 = getBinaryData(word, 24, 8);
    data4 = getBinaryData(word, 32, 8);
    data5 = getBinaryData(word, 40, 8);
    data6 = getBinaryData(word, 48, 8);
    data7 = getBinaryData(word, 56, 8);
    if ((cmd == 0xff && strcmp(msg, oldKPMsg) != 0) ||
        (cmd != 0xff && strcmp(msg, oldPKMsg) != 0)) {
      snprintf(sendBuf, sizeof(sendBuf),
               "index:%lu,%-50s data: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x "
               "0x%02x 0x%02x 0x%02x\n",
               index++, msg, data0, data1, data2, data3, data4, data5, data6,
               data7);
      write(connfd, sendBuf, strlen(sendBuf));
      if (cmd == 0xff)
        strcpy(oldKPMsg, msg);
      else
        strcpy(oldPKMsg, msg);
    }
    if (j == 400) {
      strncpy(
          wordk,
          "1111111111111111111111111111111111111111111111111111111111111111",
          (64));
      for (i = 0; i < (64); i++) {
        res = pushElement2(&wordk[i]);
        if (res == 0) {
          fprintf(stderr, "msg_io: fifo write error\n");
          exit(EXIT_FAILURE);
        }
      }
    } else if (j == 800) {
      strncpy(
          wordk,
          "1111111111111111111111111111111111111111111111111111111111111111",
          (64));
      for (i = 0; i < (64); i++) {
        res = pushElement2(&wordk[i]);
        if (res == 0) {
          fprintf(stderr, "msg_io: fifo write error\n");
          exit(EXIT_FAILURE);
        }
      }
    } else if (j == 1200) {
      strncpy(
          wordk,
          "1111111111111111111111111111111111111111111111111111111111111111",
          (64));
      for (i = 0; i < (64); i++) {
        res = pushElement2(&wordk[i]);
        if (res == 0) {
          fprintf(stderr, "msg_io: fifo write error\n");
          exit(EXIT_FAILURE);
        }
      }
    } else if (j == 1600) {
      strncpy(
          wordk,
          "1111111111111111111111111111111111111111111111111111111111111111",
          (64));
      for (i = 0; i < (64); i++) {
        res = pushElement2(&wordk[i]);
        if (res == 0) {
          fprintf(stderr, "msg_io: fifo write error\n");
          exit(EXIT_FAILURE);
        }
      }
    }
    if (j < 2000)
      j++;
    else
      j = 0;
  }
  pthread_exit("message io thread finished");
}


x86 assembly (clang, -O0):
<msg_io>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x5e0,%rsp
mov    %rdi,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
lea    -0xa0(%rbp),%rdi
xor    %esi,%esi
mov    $0x32,%edx
call   1090 <memset@plt>
lea    -0xe0(%rbp),%rdi
xor    %esi,%esi
mov    $0x32,%edx
call   1090 <memset@plt>
lea    -0x120(%rbp),%rdi
xor    %esi,%esi
mov    $0x32,%edx
call   1090 <memset@plt>
lea    -0x520(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1090 <memset@plt>
lea    -0x560(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1090 <memset@plt>
lea    -0x5a0(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1090 <memset@plt>
movq   $0x0,-0x5a8(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
lea    -0x5a0(%rbp),%rdi
lea    0xd47(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
mov    0x2d16(%rip),%rax
mov    (%rax),%edi
lea    -0x5b0(%rbp),%rsi
call   1050 <clock_gettime@plt>
mov    -0x5b0(%rbp),%eax
add    $0x4c4b40,%eax
mov    %eax,-0x5b0(%rbp)
lea    -0x5b0(%rbp),%rdi
call   1100 <tnorm@plt>
mov    0x2ce4(%rip),%rax
mov    (%rax),%edi
mov    0x2ce3(%rip),%rax
mov    (%rax),%esi
lea    -0x5b0(%rbp),%rdx
xor    %eax,%eax
mov    %eax,%ecx
call   1120 <clock_nanosleep@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x40,-0x30(%rbp)
jge    1349 <msg_io+0x149>
movslq -0x30(%rbp),%rax
lea    -0x560(%rbp),%rdi
add    %rax,%rdi
call   10c0 <popElement1@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    131e <msg_io+0x11e>
lea    -0x560(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
call   10e0 <decode@plt>
mov    %eax,-0x2c(%rbp)
lea    -0x560(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,-0x4c(%rbp)
lea    -0x560(%rbp),%rdi
mov    $0x8,%edx
mov    %edx,%esi
call   10f0 <getBinaryData@plt>
mov    %eax,-0x50(%rbp)
lea    -0x560(%rbp),%rdi
mov    $0x10,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,-0x54(%rbp)
lea    -0x560(%rbp),%rdi
mov    $0x18,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,-0x58(%rbp)
lea    -0x560(%rbp),%rdi
mov    $0x20,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,-0x5c(%rbp)
lea    -0x560(%rbp),%rdi
mov    $0x28,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,-0x60(%rbp)
lea    -0x560(%rbp),%rdi
mov    $0x30,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,-0x64(%rbp)
lea    -0x560(%rbp),%rdi
mov    $0x38,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,-0x68(%rbp)
cmpl   $0xff,-0x2c(%rbp)
jne    144b <msg_io+0x24b>
lea    -0xa0(%rbp),%rdi
lea    -0x120(%rbp),%rsi
call   10a0 <strcmp@plt>
cmp    $0x0,%rax
jne    1475 <msg_io+0x275>
cmpl   $0xff,-0x2c(%rbp)
je     155d <msg_io+0x35d>
lea    -0xa0(%rbp),%rdi
lea    -0xe0(%rbp),%rsi
call   10a0 <strcmp@plt>
cmp    $0x0,%rax
je     155d <msg_io+0x35d>
lea    -0x520(%rbp),%rdi
mov    -0x5a8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x5a8(%rbp)
mov    %eax,%ecx
lea    -0xa0(%rbp),%r8
mov    -0x4c(%rbp),%r9d
mov    -0x50(%rbp),%r12d
mov    -0x54(%rbp),%r15d
mov    -0x58(%rbp),%r14d
mov    -0x5c(%rbp),%ebx
mov    -0x60(%rbp),%r11d
mov    -0x64(%rbp),%r10d
mov    -0x68(%rbp),%eax
mov    $0x400,%esi
lea    0xb7d(%rip),%rdx
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   1080 <snprintf@plt>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x5bc(%rbp)
lea    -0x520(%rbp),%rax
mov    %rax,-0x5b8(%rbp)
lea    -0x520(%rbp),%rdi
call   1070 <strlen@plt>
mov    -0x5bc(%rbp),%edi
mov    -0x5b8(%rbp),%rsi
mov    %eax,%edx
call   1060 <write@plt>
cmpl   $0xff,-0x2c(%rbp)
jne    1545 <msg_io+0x345>
lea    -0x120(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
call   1040 <strcpy@plt>
jmp    1558 <msg_io+0x358>
lea    -0xe0(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
call   1040 <strcpy@plt>
jmp    155d <msg_io+0x35d>
cmpl   $0x190,-0x34(%rbp)
jne    15ee <msg_io+0x3ee>
lea    -0x5a0(%rbp),%rdi
lea    0xa88(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x40,-0x30(%rbp)
jge    15e9 <msg_io+0x3e9>
movslq -0x30(%rbp),%rax
lea    -0x5a0(%rbp),%rdi
add    %rax,%rdi
call   10d0 <pushElement2@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    15d6 <msg_io+0x3d6>
mov    0x2a16(%rip),%rax
mov    (%rax),%edi
lea    0xacd(%rip),%rsi
call   10b0 <fprintf@plt>
mov    0x29f9(%rip),%rax
mov    (%rax),%edi
call   1110 <exit@plt>
jmp    15db <msg_io+0x3db>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1589 <msg_io+0x389>
jmp    17b0 <msg_io+0x5b0>
cmpl   $0x320,-0x34(%rbp)
jne    167f <msg_io+0x47f>
lea    -0x5a0(%rbp),%rdi
lea    0x9f7(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x40,-0x30(%rbp)
jge    167a <msg_io+0x47a>
movslq -0x30(%rbp),%rax
lea    -0x5a0(%rbp),%rdi
add    %rax,%rdi
call   10d0 <pushElement2@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    1667 <msg_io+0x467>
mov    0x2985(%rip),%rax
mov    (%rax),%edi
lea    0xa3c(%rip),%rsi
call   10b0 <fprintf@plt>
mov    0x2968(%rip),%rax
mov    (%rax),%edi
call   1110 <exit@plt>
jmp    166c <msg_io+0x46c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    161a <msg_io+0x41a>
jmp    17ab <msg_io+0x5ab>
cmpl   $0x4b0,-0x34(%rbp)
jne    1710 <msg_io+0x510>
lea    -0x5a0(%rbp),%rdi
lea    0x966(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x40,-0x30(%rbp)
jge    170b <msg_io+0x50b>
movslq -0x30(%rbp),%rax
lea    -0x5a0(%rbp),%rdi
add    %rax,%rdi
call   10d0 <pushElement2@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    16f8 <msg_io+0x4f8>
mov    0x28f4(%rip),%rax
mov    (%rax),%edi
lea    0x9ab(%rip),%rsi
call   10b0 <fprintf@plt>
mov    0x28d7(%rip),%rax
mov    (%rax),%edi
call   1110 <exit@plt>
jmp    16fd <msg_io+0x4fd>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16ab <msg_io+0x4ab>
jmp    17a6 <msg_io+0x5a6>
cmpl   $0x640,-0x34(%rbp)
jne    17a1 <msg_io+0x5a1>
lea    -0x5a0(%rbp),%rdi
lea    0x8d5(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x40,-0x30(%rbp)
jge    179c <msg_io+0x59c>
movslq -0x30(%rbp),%rax
lea    -0x5a0(%rbp),%rdi
add    %rax,%rdi
call   10d0 <pushElement2@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    1789 <msg_io+0x589>
mov    0x2863(%rip),%rax
mov    (%rax),%edi
lea    0x91a(%rip),%rsi
call   10b0 <fprintf@plt>
mov    0x2846(%rip),%rax
mov    (%rax),%edi
call   1110 <exit@plt>
jmp    178e <msg_io+0x58e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    173c <msg_io+0x53c>
jmp    17a1 <msg_io+0x5a1>
jmp    17a6 <msg_io+0x5a6>
jmp    17ab <msg_io+0x5ab>
jmp    17b0 <msg_io+0x5b0>
cmpl   $0x7d0,-0x34(%rbp)
jge    17cb <msg_io+0x5cb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17d2 <msg_io+0x5d2>
movl   $0x0,-0x34(%rbp)
jmp    12d8 <msg_io+0xd8>

x86 assembly (clang, -O2):
<msg_io>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x598,%rsp
mov    %rdi,%rbx
xorps  %xmm0,%xmm0
movaps %xmm0,0x130(%rsp)
movaps %xmm0,0x120(%rsp)
movaps %xmm0,0x110(%rsp)
movw   $0x0,0x140(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movw   $0x0,0x100(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movw   $0x0,0xc0(%rsp)
lea    0x190(%rsp),%rdi
mov    $0x400,%edx
xor    %esi,%esi
call   1090 <memset@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
movaps %xmm0,0x170(%rsp)
movaps %xmm0,0x160(%rsp)
movaps %xmm0,0x150(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
mov    (%rbx),%eax
mov    %eax,0x18(%rsp)
lea    0xd28(%rip),%rsi
lea    0x50(%rsp),%rdi
mov    $0x40,%edx
call   1030 <strncpy@plt>
mov    0x2cf2(%rip),%rax
mov    (%rax),%edi
lea    0x8(%rsp),%rsi
call   1050 <clock_gettime@plt>
lea    0x110(%rsp),%r15
xor    %eax,%eax
xor    %ecx,%ecx
mov    %rcx,0x20(%rsp)
jmp    1321 <msg_io+0x121>
nopl   (%rax)
cmp    $0x7d0,%ebp
lea    0x1(%rbp),%eax
mov    $0x0,%ecx
cmovge %ecx,%eax
mov    %rax,0x10(%rsp)
addl   $0x4c4b40,0x8(%rsp)
lea    0x8(%rsp),%rbx
mov    %rbx,%rdi
call   1100 <tnorm@plt>
mov    0x2c9e(%rip),%rax
mov    (%rax),%edi
mov    0x2c9d(%rip),%rax
mov    (%rax),%esi
mov    %rbx,%rdx
xor    %ecx,%ecx
call   1120 <clock_nanosleep@plt>
xor    %ebx,%ebx
nopl   0x0(%rax)
lea    (%rsp,%rbx,1),%rdi
add    $0x150,%rdi
call   10c0 <popElement1@plt>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    1360 <msg_io+0x160>
lea    0x150(%rsp),%rbx
mov    %rbx,%rdi
mov    %r15,%rsi
call   10e0 <decode@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,0x1c(%rsp)
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %rax,0x48(%rsp)
mov    %rbx,%rdi
mov    $0x10,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %rax,0x40(%rsp)
mov    %rbx,%rdi
mov    $0x18,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %rax,0x38(%rsp)
mov    %rbx,%rdi
mov    $0x20,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %rax,0x30(%rsp)
mov    %rbx,%rdi
mov    $0x28,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %rax,0x28(%rsp)
mov    %rbx,%rdi
mov    $0x30,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,%r13d
mov    %rbx,%rdi
mov    $0x38,%esi
mov    $0x8,%edx
call   10f0 <getBinaryData@plt>
mov    %eax,%r14d
mov    %r15,%rdi
cmp    $0xff,%ebp
jne    1460 <msg_io+0x260>
lea    0x90(%rsp),%r12
jmp    1468 <msg_io+0x268>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0xd0(%rsp),%r12
mov    %r12,%rsi
call   10a0 <strcmp@plt>
test   %rax,%rax
je     14f1 <msg_io+0x2f1>
mov    0x20(%rsp),%rcx
lea    0x1(%rcx),%rbp
sub    $0x8,%rsp
mov    %r15,%rbx
lea    0x198(%rsp),%r15
mov    %r15,%rdi
mov    $0x400,%esi
lea    0xba5(%rip),%rdx
mov    %rbx,%r8
mov    0x24(%rsp),%r9d
push   %r14
push   %r13
push   0x40(%rsp)
push   0x50(%rsp)
push   0x60(%rsp)
push   0x70(%rsp)
push   0x80(%rsp)
call   1080 <snprintf@plt>
add    $0x40,%rsp
mov    %r15,%rdi
call   1070 <strlen@plt>
mov    0x18(%rsp),%edi
mov    %r15,%rsi
mov    %rbx,%r15
mov    %eax,%edx
call   1060 <write@plt>
mov    %r12,%rdi
mov    %rbx,%rsi
call   1040 <strcpy@plt>
mov    %rbp,0x20(%rsp)
mov    0x10(%rsp),%rbp
cmp    $0x4af,%ebp
jg     1560 <msg_io+0x360>
cmp    $0x190,%ebp
je     15c0 <msg_io+0x3c0>
cmp    $0x320,%ebp
jne    1310 <msg_io+0x110>
lea    0x50(%rsp),%rdi
lea    0xade(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
xor    %ebx,%ebx
xchg   %ax,%ax
lea    (%rsp,%rbx,1),%rdi
add    $0x50,%rdi
call   10d0 <pushElement2@plt>
test   %eax,%eax
je     1640 <msg_io+0x440>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    1530 <msg_io+0x330>
jmp    1310 <msg_io+0x110>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x4b0,%ebp
je     1600 <msg_io+0x400>
cmp    $0x640,%ebp
jne    1310 <msg_io+0x110>
lea    0x50(%rsp),%rdi
lea    0xa7c(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
xor    %ebx,%ebx
lea    (%rsp,%rbx,1),%rdi
add    $0x50,%rdi
call   10d0 <pushElement2@plt>
test   %eax,%eax
je     1640 <msg_io+0x440>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    1590 <msg_io+0x390>
jmp    1310 <msg_io+0x110>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x50(%rsp),%rdi
lea    0xa34(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%rsp,%rbx,1),%rdi
add    $0x50,%rdi
call   10d0 <pushElement2@plt>
test   %eax,%eax
je     1640 <msg_io+0x440>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    15e0 <msg_io+0x3e0>
jmp    1310 <msg_io+0x110>
lea    0x50(%rsp),%rdi
lea    0x9f4(%rip),%rsi
mov    $0x40,%edx
call   1030 <strncpy@plt>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%rsp,%rbx,1),%rdi
add    $0x50,%rdi
call   10d0 <pushElement2@plt>
test   %eax,%eax
je     1640 <msg_io+0x440>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    1620 <msg_io+0x420>
jmp    1310 <msg_io+0x110>
mov    0x2989(%rip),%rax
mov    (%rax),%edi
lea    0xa40(%rip),%rsi
call   10b0 <fprintf@plt>
mov    0x296c(%rip),%rax
mov    (%rax),%edi
call   1110 <exit@plt>

LLVM IR (-O0):
%struct.timespec = type { i32 }
@.str = [65 x i8] c"1111111111111111111111111111111111111111111111111111111111111111\00"
@CLOCK_MONOTONIC = global i32 0
@TIMER_ABSTIME = global i32 0
@.str.1 = [79 x i8] c"index:%lu,%-50s data: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\0A\00"
@stderr = global i32 0
@.str.2 = [26 x i8] c"msg_io: fifo write error\0A\00"
@EXIT_FAILURE = global i32 0
define i8* @msg_io(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca [50 x i8]
%18 = alloca [50 x i8]
%19 = alloca [50 x i8]
%20 = alloca [1024 x i8]
%21 = alloca [64 x i8]
%22 = alloca [64 x i8]
%23 = alloca i64
%24 = alloca %struct.timespec
store i8* %0, i8** %2
store i32 0, i32* %5
%25 = bitcast [50 x i8]* %17 to i8*
%26 = bitcast [50 x i8]* %18 to i8*
%27 = bitcast [50 x i8]* %19 to i8*
%28 = bitcast [1024 x i8]* %20 to i8*
%29 = bitcast [64 x i8]* %21 to i8*
%30 = bitcast [64 x i8]* %22 to i8*
store i64 0, i64* %23
%31 = load i8*, i8** %2
%32 = bitcast i8* %31 to i32*
store i32* %32, i32** %8
%33 = load i32*, i32** %8
%34 = load i32, i32* %33
store i32 %34, i32* %7
%35 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 0
%36 = call i32 @strncpy(i8* %35, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
%37 = load i32, i32* @CLOCK_MONOTONIC
%38 = call i32 @clock_gettime(i32 %37, %struct.timespec* %24)
br label %39
39: ; preds = %1, %238
%40 = getelementptr inbounds %struct.timespec, %struct.timespec* %24, i32 0, i32 0
%41 = load i32, i32* %40
%42 = add nsw i32 %41, 5000000
store i32 %42, i32* %40
%43 = call i32 @tnorm(%struct.timespec* %24)
%44 = load i32, i32* @CLOCK_MONOTONIC
%45 = load i32, i32* @TIMER_ABSTIME
%46 = call i32 @clock_nanosleep(i32 %44, i32 %45, %struct.timespec* %24, i32* null)
store i32 0, i32* %4
br label %47
47: ; preds = %55, %39
%48 = load i32, i32* %4
%49 = icmp slt i32 %48, 64
br i1 %49, label %50, label %58
50: ; preds = %47
%51 = load i32, i32* %4
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 %52
%54 = call i32 @popElement1(i8* %53)
br label %55
55: ; preds = %50
%56 = load i32, i32* %4
%57 = add nsw i32 %56, 1
store i32 %57, i32* %4
br label %47
58: ; preds = %47
%59 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%60 = getelementptr inbounds [50 x i8], [50 x i8]* %17, i64 0, i64 0
%61 = call i32 @decode(i8* %59, i8* %60)
store i32 %61, i32* %3
%62 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%63 = call i32 @getBinaryData(i8* %62, i32 0, i32 8)
store i32 %63, i32* %9
%64 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%65 = call i32 @getBinaryData(i8* %64, i32 8, i32 8)
store i32 %65, i32* %10
%66 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%67 = call i32 @getBinaryData(i8* %66, i32 16, i32 8)
store i32 %67, i32* %11
%68 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%69 = call i32 @getBinaryData(i8* %68, i32 24, i32 8)
store i32 %69, i32* %12
%70 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%71 = call i32 @getBinaryData(i8* %70, i32 32, i32 8)
store i32 %71, i32* %13
%72 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%73 = call i32 @getBinaryData(i8* %72, i32 40, i32 8)
store i32 %73, i32* %14
%74 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%75 = call i32 @getBinaryData(i8* %74, i32 48, i32 8)
store i32 %75, i32* %15
%76 = getelementptr inbounds [64 x i8], [64 x i8]* %21, i64 0, i64 0
%77 = call i32 @getBinaryData(i8* %76, i32 56, i32 8)
store i32 %77, i32* %16
%78 = load i32, i32* %3
%79 = icmp eq i32 %78, 255
br i1 %79, label %80, label %85
80: ; preds = %58
%81 = getelementptr inbounds [50 x i8], [50 x i8]* %17, i64 0, i64 0
%82 = getelementptr inbounds [50 x i8], [50 x i8]* %19, i64 0, i64 0
%83 = call i64 @strcmp(i8* %81, i8* %82)
%84 = icmp ne i64 %83, 0
br i1 %84, label %93, label %85
85: ; preds = %80, %58
%86 = load i32, i32* %3
%87 = icmp ne i32 %86, 255
br i1 %87, label %88, label %124
88: ; preds = %85
%89 = getelementptr inbounds [50 x i8], [50 x i8]* %17, i64 0, i64 0
%90 = getelementptr inbounds [50 x i8], [50 x i8]* %18, i64 0, i64 0
%91 = call i64 @strcmp(i8* %89, i8* %90)
%92 = icmp ne i64 %91, 0
br i1 %92, label %93, label %124
93: ; preds = %88, %80
%94 = getelementptr inbounds [1024 x i8], [1024 x i8]* %20, i64 0, i64 0
%95 = load i64, i64* %23
%96 = add i64 %95, 1
store i64 %96, i64* %23
%97 = trunc i64 %95 to i32
%98 = getelementptr inbounds [50 x i8], [50 x i8]* %17, i64 0, i64 0
%99 = load i32, i32* %9
%100 = load i32, i32* %10
%101 = load i32, i32* %11
%102 = load i32, i32* %12
%103 = load i32, i32* %13
%104 = load i32, i32* %14
%105 = load i32, i32* %15
%106 = load i32, i32* %16
%107 = call i32 @snprintf(i8* %94, i32 1024, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.1, i64 0, i64 0), i32 %97, i8* %98, i32 %99, i32 %100, i32 %101, i32 %102, i32 %103, i32 %104, i32 %105, i32 %106)
%108 = load i32, i32* %7
%109 = getelementptr inbounds [1024 x i8], [1024 x i8]* %20, i64 0, i64 0
%110 = getelementptr inbounds [1024 x i8], [1024 x i8]* %20, i64 0, i64 0
%111 = call i32 @strlen(i8* %110)
%112 = call i32 @write(i32 %108, i8* %109, i32 %111)
%113 = load i32, i32* %3
%114 = icmp eq i32 %113, 255
br i1 %114, label %115, label %119
115: ; preds = %93
%116 = getelementptr inbounds [50 x i8], [50 x i8]* %19, i64 0, i64 0
%117 = getelementptr inbounds [50 x i8], [50 x i8]* %17, i64 0, i64 0
%118 = call i32 @strcpy(i8* %116, i8* %117)
br label %123
119: ; preds = %93
%120 = getelementptr inbounds [50 x i8], [50 x i8]* %18, i64 0, i64 0
%121 = getelementptr inbounds [50 x i8], [50 x i8]* %17, i64 0, i64 0
%122 = call i32 @strcpy(i8* %120, i8* %121)
br label %123
123: ; preds = %119, %115
br label %124
124: ; preds = %123, %88, %85
%125 = load i32, i32* %5
%126 = icmp eq i32 %125, 400
br i1 %126, label %127, label %150
127: ; preds = %124
%128 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 0
%129 = call i32 @strncpy(i8* %128, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
store i32 0, i32* %4
br label %130
130: ; preds = %146, %127
%131 = load i32, i32* %4
%132 = icmp slt i32 %131, 64
br i1 %132, label %133, label %149
133: ; preds = %130
%134 = load i32, i32* %4
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 %135
%137 = call i32 @pushElement2(i8* %136)
store i32 %137, i32* %6
%138 = load i32, i32* %6
%139 = icmp eq i32 %138, 0
br i1 %139, label %140, label %145
140: ; preds = %133
%141 = load i32, i32* @stderr
%142 = call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
%143 = load i32, i32* @EXIT_FAILURE
%144 = call i32 @exit(i32 %143)
unreachable
145: ; preds = %133
br label %146
146: ; preds = %145
%147 = load i32, i32* %4
%148 = add nsw i32 %147, 1
store i32 %148, i32* %4
br label %130
149: ; preds = %130
br label %231
150: ; preds = %124
%151 = load i32, i32* %5
%152 = icmp eq i32 %151, 800
br i1 %152, label %153, label %176
153: ; preds = %150
%154 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 0
%155 = call i32 @strncpy(i8* %154, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
store i32 0, i32* %4
br label %156
156: ; preds = %172, %153
%157 = load i32, i32* %4
%158 = icmp slt i32 %157, 64
br i1 %158, label %159, label %175
159: ; preds = %156
%160 = load i32, i32* %4
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 %161
%163 = call i32 @pushElement2(i8* %162)
store i32 %163, i32* %6
%164 = load i32, i32* %6
%165 = icmp eq i32 %164, 0
br i1 %165, label %166, label %171
166: ; preds = %159
%167 = load i32, i32* @stderr
%168 = call i32 @fprintf(i32 %167, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
%169 = load i32, i32* @EXIT_FAILURE
%170 = call i32 @exit(i32 %169)
unreachable
171: ; preds = %159
br label %172
172: ; preds = %171
%173 = load i32, i32* %4
%174 = add nsw i32 %173, 1
store i32 %174, i32* %4
br label %156
175: ; preds = %156
br label %230
176: ; preds = %150
%177 = load i32, i32* %5
%178 = icmp eq i32 %177, 1200
br i1 %178, label %179, label %202
179: ; preds = %176
%180 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 0
%181 = call i32 @strncpy(i8* %180, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
store i32 0, i32* %4
br label %182
182: ; preds = %198, %179
%183 = load i32, i32* %4
%184 = icmp slt i32 %183, 64
br i1 %184, label %185, label %201
185: ; preds = %182
%186 = load i32, i32* %4
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 %187
%189 = call i32 @pushElement2(i8* %188)
store i32 %189, i32* %6
%190 = load i32, i32* %6
%191 = icmp eq i32 %190, 0
br i1 %191, label %192, label %197
192: ; preds = %185
%193 = load i32, i32* @stderr
%194 = call i32 @fprintf(i32 %193, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
%195 = load i32, i32* @EXIT_FAILURE
%196 = call i32 @exit(i32 %195)
unreachable
197: ; preds = %185
br label %198
198: ; preds = %197
%199 = load i32, i32* %4
%200 = add nsw i32 %199, 1
store i32 %200, i32* %4
br label %182
201: ; preds = %182
br label %229
202: ; preds = %176
%203 = load i32, i32* %5
%204 = icmp eq i32 %203, 1600
br i1 %204, label %205, label %228
205: ; preds = %202
%206 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 0
%207 = call i32 @strncpy(i8* %206, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
store i32 0, i32* %4
br label %208
208: ; preds = %224, %205
%209 = load i32, i32* %4
%210 = icmp slt i32 %209, 64
br i1 %210, label %211, label %227
211: ; preds = %208
%212 = load i32, i32* %4
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [64 x i8], [64 x i8]* %22, i64 0, i64 %213
%215 = call i32 @pushElement2(i8* %214)
store i32 %215, i32* %6
%216 = load i32, i32* %6
%217 = icmp eq i32 %216, 0
br i1 %217, label %218, label %223
218: ; preds = %211
%219 = load i32, i32* @stderr
%220 = call i32 @fprintf(i32 %219, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
%221 = load i32, i32* @EXIT_FAILURE
%222 = call i32 @exit(i32 %221)
unreachable
223: ; preds = %211
br label %224
224: ; preds = %223
%225 = load i32, i32* %4
%226 = add nsw i32 %225, 1
store i32 %226, i32* %4
br label %208
227: ; preds = %208
br label %228
228: ; preds = %227, %202
br label %229
229: ; preds = %228, %201
br label %230
230: ; preds = %229, %175
br label %231
231: ; preds = %230, %149
%232 = load i32, i32* %5
%233 = icmp slt i32 %232, 2000
br i1 %233, label %234, label %237
234: ; preds = %231
%235 = load i32, i32* %5
%236 = add nsw i32 %235, 1
store i32 %236, i32* %5
br label %238
237: ; preds = %231
store i32 0, i32* %5
br label %238
238: ; preds = %237, %234
br label %39
}

LLVM IR (-O2):
%struct.timespec = type { i32 }
@.str = [65 x i8] c"1111111111111111111111111111111111111111111111111111111111111111\00"
@CLOCK_MONOTONIC = global i32 0
@TIMER_ABSTIME = global i32 0
@.str.1 = [79 x i8] c"index:%lu,%-50s data: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\0A\00"
@stderr = global i32 0
@.str.2 = [26 x i8] c"msg_io: fifo write error\0A\00"
@EXIT_FAILURE = global i32 0
define noalias i8* @msg_io(i8* nocapture %0) {
%2 = alloca [50 x i8]
%3 = alloca [50 x i8]
%4 = alloca [50 x i8]
%5 = alloca [1024 x i8]
%6 = alloca [64 x i8]
%7 = alloca [64 x i8]
%8 = alloca %struct.timespec
%9 = getelementptr inbounds [50 x i8], [50 x i8]* %2, i64 0, i64 0
%10 = getelementptr inbounds [50 x i8], [50 x i8]* %3, i64 0, i64 0
%11 = getelementptr inbounds [50 x i8], [50 x i8]* %4, i64 0, i64 0
%12 = getelementptr inbounds [1024 x i8], [1024 x i8]* %5, i64 0, i64 0
%13 = getelementptr inbounds [64 x i8], [64 x i8]* %6, i64 0, i64 0
%14 = getelementptr inbounds [64 x i8], [64 x i8]* %7, i64 0, i64 0
%15 = bitcast %struct.timespec* %8 to i8*
%16 = bitcast i8* %0 to i32*
%17 = load i32, i32* %16
%18 = call i32 @strncpy(i8* %14, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
%19 = load i32, i32* @CLOCK_MONOTONIC
%20 = call i32 @clock_gettime(i32 %19, %struct.timespec* %8)
%21 = getelementptr inbounds %struct.timespec, %struct.timespec* %8, i64 0, i32 0
br label %22
22: ; preds = %124, %1
%23 = phi i32 [ 0, %1 ], [ %127, %124 ]
%24 = phi i64 [ 0, %1 ], [ %63, %124 ]
%25 = load i32, i32* %21
%26 = add nsw i32 %25, 5000000
store i32 %26, i32* %21
%27 = call i32 @tnorm(%struct.timespec* %8)
%28 = load i32, i32* @CLOCK_MONOTONIC
%29 = load i32, i32* @TIMER_ABSTIME
%30 = call i32 @clock_nanosleep(i32 %28, i32 %29, %struct.timespec* %8, i32* null)
br label %31
31: ; preds = %22, %31
%32 = phi i64 [ 0, %22 ], [ %35, %31 ]
%33 = getelementptr inbounds [64 x i8], [64 x i8]* %6, i64 0, i64 %32
%34 = call i32 @popElement1(i8* %33)
%35 = add nuw nsw i64 %32, 1
%36 = icmp eq i64 %35, 64
br i1 %36, label %37, label %31
37: ; preds = %31
%38 = call i32 @decode(i8* %13, i8* %9)
%39 = call i32 @getBinaryData(i8* %13, i32 0, i32 8)
%40 = call i32 @getBinaryData(i8* %13, i32 8, i32 8)
%41 = call i32 @getBinaryData(i8* %13, i32 16, i32 8)
%42 = call i32 @getBinaryData(i8* %13, i32 24, i32 8)
%43 = call i32 @getBinaryData(i8* %13, i32 32, i32 8)
%44 = call i32 @getBinaryData(i8* %13, i32 40, i32 8)
%45 = call i32 @getBinaryData(i8* %13, i32 48, i32 8)
%46 = call i32 @getBinaryData(i8* %13, i32 56, i32 8)
%47 = icmp eq i32 %38, 255
br i1 %47, label %48, label %51
48: ; preds = %37
%49 = call i64 @strcmp(i8* %9, i8* %11)
%50 = icmp eq i64 %49, 0
br i1 %50, label %62, label %54
51: ; preds = %37
%52 = call i64 @strcmp(i8* %9, i8* %10)
%53 = icmp eq i64 %52, 0
br i1 %53, label %62, label %54
54: ; preds = %51, %48
%55 = phi i8* [ %10, %51 ], [ %11, %48 ]
%56 = add i64 %24, 1
%57 = trunc i64 %24 to i32
%58 = call i32 @snprintf(i8* %12, i32 1024, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.1, i64 0, i64 0), i32 %57, i8* %9, i32 %39, i32 %40, i32 %41, i32 %42, i32 %43, i32 %44, i32 %45, i32 %46)
%59 = call i32 @strlen(i8* %12)
%60 = call i32 @write(i32 %17, i8* %12, i32 %59)
%61 = call i32 @strcpy(i8* %55, i8* %9)
br label %62
62: ; preds = %54, %48, %51
%63 = phi i64 [ %24, %51 ], [ %24, %48 ], [ %56, %54 ]
switch i32 %23, label %124 [
i32 400, label %64
i32 800, label %79
i32 1200, label %94
i32 1600, label %109
]
64: ; preds = %62
%65 = call i32 @strncpy(i8* %14, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
br label %69
66: ; preds = %69
%67 = add nuw nsw i64 %70, 1
%68 = icmp eq i64 %67, 64
br i1 %68, label %124, label %69
69: ; preds = %64, %66
%70 = phi i64 [ 0, %64 ], [ %67, %66 ]
%71 = getelementptr inbounds [64 x i8], [64 x i8]* %7, i64 0, i64 %70
%72 = call i32 @pushElement2(i8* %71)
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %66
74: ; preds = %69
%75 = load i32, i32* @stderr
%76 = call i32 @fprintf(i32 %75, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
%77 = load i32, i32* @EXIT_FAILURE
%78 = call i32 @exit(i32 %77)
unreachable
79: ; preds = %62
%80 = call i32 @strncpy(i8* %14, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
br label %84
81: ; preds = %84
%82 = add nuw nsw i64 %85, 1
%83 = icmp eq i64 %82, 64
br i1 %83, label %124, label %84
84: ; preds = %79, %81
%85 = phi i64 [ 0, %79 ], [ %82, %81 ]
%86 = getelementptr inbounds [64 x i8], [64 x i8]* %7, i64 0, i64 %85
%87 = call i32 @pushElement2(i8* %86)
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %81
89: ; preds = %84
%90 = load i32, i32* @stderr
%91 = call i32 @fprintf(i32 %90, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
%92 = load i32, i32* @EXIT_FAILURE
%93 = call i32 @exit(i32 %92)
unreachable
94: ; preds = %62
%95 = call i32 @strncpy(i8* %14, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
br label %99
96: ; preds = %99
%97 = add nuw nsw i64 %100, 1
%98 = icmp eq i64 %97, 64
br i1 %98, label %124, label %99
99: ; preds = %94, %96
%100 = phi i64 [ 0, %94 ], [ %97, %96 ]
%101 = getelementptr inbounds [64 x i8], [64 x i8]* %7, i64 0, i64 %100
%102 = call i32 @pushElement2(i8* %101)
%103 = icmp eq i32 %102, 0
br i1 %103, label %104, label %96
104: ; preds = %99
%105 = load i32, i32* @stderr
%106 = call i32 @fprintf(i32 %105, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
%107 = load i32, i32* @EXIT_FAILURE
%108 = call i32 @exit(i32 %107)
unreachable
109: ; preds = %62
%110 = call i32 @strncpy(i8* %14, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), i32 64)
br label %114
111: ; preds = %114
%112 = add nuw nsw i64 %115, 1
%113 = icmp eq i64 %112, 64
br i1 %113, label %124, label %114
114: ; preds = %109, %111
%115 = phi i64 [ 0, %109 ], [ %112, %111 ]
%116 = getelementptr inbounds [64 x i8], [64 x i8]* %7, i64 0, i64 %115
%117 = call i32 @pushElement2(i8* %116)
%118 = icmp eq i32 %117, 0
br i1 %118, label %119, label %111
119: ; preds = %114
%120 = load i32, i32* @stderr
%121 = call i32 @fprintf(i32 %120, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0))
%122 = load i32, i32* @EXIT_FAILURE
%123 = call i32 @exit(i32 %122)
unreachable
124: ; preds = %111, %96, %81, %66, %62
%125 = icmp slt i32 %23, 2000
%126 = add nsw i32 %23, 1
%127 = select i1 %125, i32 %126, i32 0
br label %22
}