#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*/ whence;
typedef int /*<<< orphan*/ sysnr;
typedef scalar_t__ ssize_t;
typedef int /*<<< orphan*/ sret;
typedef int /*<<< orphan*/ sj;
typedef int /*<<< orphan*/ ret;
typedef int /*<<< orphan*/ offset;
typedef int /*<<< orphan*/ off_t;
typedef int /*<<< orphan*/ mode;
typedef int /*<<< orphan*/ len;
typedef int /*<<< orphan*/ flags;
typedef int /*<<< orphan*/ fd;
typedef int /*<<< orphan*/ arg;

/* Variables and functions */
int /*<<< orphan*/ IPPROTO_TCP;
int /*<<< orphan*/ TCP_NODELAY;
int close(int);
int errno;
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ free(char *);
int /*<<< orphan*/ lseek(int, int /*<<< orphan*/, int);
char *malloc(size_t);
int open(char *, int, int);
int /*<<< orphan*/ perror(char *);
scalar_t__ read(int, char *, int);
int /*<<< orphan*/ setsockopt(int, int /*<<< orphan*/, int /*<<< orphan*/,
                              char *, int);
int /*<<< orphan*/ stderr;
void *write(int, char *, int);
int handle_syscalls(int s) {
  int sysnr;
  ssize_t sret;
  size_t j;
  while (1) {
    j = 0;
    while (j < sizeof(sysnr)) {
      sret = read(s, ((char *)&sysnr) + j, sizeof(sysnr) - j);
      if (sret < 0)
        goto out;
      j += sret;
    }
    switch (sysnr) {
    case 0: {
      int arg = 0;
      j = 0;
      while (j < sizeof(arg)) {
        sret = read(s, ((char *)&arg) + j, sizeof(arg) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      close(s);
      if (arg == -14)
        fprintf(stderr, "Did HermitCore receive an exception?\n");
      exit(arg);
      break;
    }
    case 1: {
      int fd;
      size_t len;
      char *buff;
      j = 0;
      while (j < sizeof(fd)) {
        sret = read(s, ((char *)&fd) + j, sizeof(fd) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      j = 0;
      while (j < sizeof(len)) {
        sret = read(s, ((char *)&len) + j, sizeof(len) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      buff = malloc(len);
      if (!buff) {
        fprintf(stderr, "Proxy: not enough memory");
        return 1;
      }
      j = 0;
      while (j < len) {
        sret = read(s, buff + j, len - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      if (fd > 2) {
        sret = write(fd, buff, len);
        j = 0;
        while (j < sizeof(sret)) {
          int l = write(s, ((char *)&sret) + j, sizeof(sret) - j);
          if (l < 0)
            goto out;
          j += l;
        }
      } else {
        j = 0;
        while (j < len) {
          sret = write(fd, buff + j, len - j);
          if (sret < 0)
            goto out;
          j += sret;
        }
      }
      free(buff);
      break;
    }
    case 2: {
      size_t len;
      char *fname;
      int flags, mode, ret;
      j = 0;
      while (j < sizeof(len)) {
        sret = read(s, ((char *)&len) + j, sizeof(len) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      fname = malloc(len);
      if (!fname)
        goto out;
      j = 0;
      while (j < len) {
        sret = read(s, fname + j, len - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      j = 0;
      while (j < sizeof(flags)) {
        sret = read(s, ((char *)&flags) + j, sizeof(flags) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      j = 0;
      while (j < sizeof(mode)) {
        sret = read(s, ((char *)&mode) + j, sizeof(mode) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      ret = open(fname, flags, mode);
      j = 0;
      while (j < sizeof(ret)) {
        sret = write(s, ((char *)&ret) + j, sizeof(ret) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      free(fname);
      break;
    }
    case 3: {
      int fd, ret;
      j = 0;
      while (j < sizeof(fd)) {
        sret = read(s, ((char *)&fd) + j, sizeof(fd) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      if (fd > 2)
        ret = close(fd);
      else
        ret = 0;
      j = 0;
      while (j < sizeof(ret)) {
        sret = write(s, ((char *)&ret) + j, sizeof(ret) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      break;
    }
    case 4: {
      int fd, flag;
      size_t len;
      ssize_t sj;
      char *buff;
      j = 0;
      while (j < sizeof(fd)) {
        sret = read(s, ((char *)&fd) + j, sizeof(fd) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      j = 0;
      while (j < sizeof(len)) {
        sret = read(s, ((char *)&len) + j, sizeof(len) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      buff = malloc(len);
      if (!buff)
        goto out;
      sj = read(fd, buff, len);
      flag = 0;
      setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(int));
      j = 0;
      while (j < sizeof(sj)) {
        sret = write(s, ((char *)&sj) + j, sizeof(sj) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      if (sj > 0) {
        size_t i = 0;
        while (i < sj) {
          sret = write(s, buff + i, sj - i);
          if (sret < 0)
            goto out;
          i += sret;
        }
      }
      flag = 1;
      setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(int));
      free(buff);
      break;
    }
    case 5: {
      int fd, whence;
      off_t offset;
      j = 0;
      while (j < sizeof(fd)) {
        sret = read(s, ((char *)&fd) + j, sizeof(fd) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      j = 0;
      while (j < sizeof(offset)) {
        sret = read(s, ((char *)&offset) + j, sizeof(offset) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      j = 0;
      while (j < sizeof(whence)) {
        sret = read(s, ((char *)&whence) + j, sizeof(whence) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      offset = lseek(fd, offset, whence);
      j = 0;
      while (j < sizeof(offset)) {
        sret = write(s, ((char *)&offset) + j, sizeof(offset) - j);
        if (sret < 0)
          goto out;
        j += sret;
      }
      break;
    }
    default:
      fprintf(stderr, "Proxy: invalid syscall number %d, errno %d, ret %zd\n",
              sysnr, errno, sret);
      close(s);
      exit(1);
      break;
    }
  }
out:
  perror("Proxy -- communication error");
  return 1;
}


x86 assembly (clang, -O0):
<handle_syscalls>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %edi,-0x8(%rbp)
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    1211 <handle_syscalls+0x61>
mov    -0x8(%rbp),%edi
lea    -0xc(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    1200 <handle_syscalls+0x50>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    11c6 <handle_syscalls+0x16>
mov    -0xc(%rbp),%eax
mov    %rax,-0xa8(%rbp)
sub    $0x5,%rax
ja     1b15 <handle_syscalls+0x965>
mov    -0xa8(%rbp),%rax
lea    0xdcd(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x24(%rbp)
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    1296 <handle_syscalls+0xe6>
mov    -0x8(%rbp),%edi
lea    -0x24(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    1285 <handle_syscalls+0xd5>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    124b <handle_syscalls+0x9b>
mov    -0x8(%rbp),%edi
call   1070 <close@plt>
cmpl   $0xfffffff2,-0x24(%rbp)
jne    12bf <handle_syscalls+0x10f>
mov    0x2d21(%rip),%rax
mov    (%rax),%edi
lea    0xd60(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x24(%rbp),%edi
call   10d0 <exit@plt>
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    131a <handle_syscalls+0x16a>
mov    -0x8(%rbp),%edi
lea    -0x28(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    1309 <handle_syscalls+0x159>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    12cf <handle_syscalls+0x11f>
movq   $0x0,-0x20(%rbp)
cmpq   $0x8,-0x20(%rbp)
jae    136d <handle_syscalls+0x1bd>
mov    -0x8(%rbp),%edi
lea    -0x30(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x8,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    135c <handle_syscalls+0x1ac>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1322 <handle_syscalls+0x172>
mov    -0x30(%rbp),%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    13a8 <handle_syscalls+0x1f8>
mov    0x2c44(%rip),%rax
mov    (%rax),%edi
lea    0xca9(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1b66 <handle_syscalls+0x9b6>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    13fd <handle_syscalls+0x24d>
mov    -0x8(%rbp),%edi
mov    -0x38(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    13ec <handle_syscalls+0x23c>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    13b0 <handle_syscalls+0x200>
cmpl   $0x2,-0x28(%rbp)
jle    1473 <handle_syscalls+0x2c3>
mov    -0x28(%rbp),%edi
mov    -0x38(%rbp),%rsi
mov    -0x30(%rbp),%rax
mov    %eax,%edx
call   1050 <write@plt>
mov    %rax,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
cmpq   $0x8,-0x20(%rbp)
jae    146e <handle_syscalls+0x2be>
mov    -0x8(%rbp),%edi
lea    -0x18(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x8,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1050 <write@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    145d <handle_syscalls+0x2ad>
jmp    1b53 <handle_syscalls+0x9a3>
movslq -0x3c(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1425 <handle_syscalls+0x275>
jmp    14cd <handle_syscalls+0x31d>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    14c8 <handle_syscalls+0x318>
mov    -0x28(%rbp),%edi
mov    -0x38(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1050 <write@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    14b7 <handle_syscalls+0x307>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    147b <handle_syscalls+0x2cb>
jmp    14cd <handle_syscalls+0x31d>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
jmp    1b4e <handle_syscalls+0x99e>
movq   $0x0,-0x20(%rbp)
cmpq   $0x8,-0x20(%rbp)
jae    152e <handle_syscalls+0x37e>
mov    -0x8(%rbp),%edi
lea    -0x48(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x8,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    151d <handle_syscalls+0x36d>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    14e3 <handle_syscalls+0x333>
mov    -0x48(%rbp),%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jne    154b <handle_syscalls+0x39b>
jmp    1b53 <handle_syscalls+0x9a3>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    15a0 <handle_syscalls+0x3f0>
mov    -0x8(%rbp),%edi
mov    -0x50(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    -0x48(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    158f <handle_syscalls+0x3df>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1553 <handle_syscalls+0x3a3>
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    15f3 <handle_syscalls+0x443>
mov    -0x8(%rbp),%edi
lea    -0x54(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    15e2 <handle_syscalls+0x432>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    15a8 <handle_syscalls+0x3f8>
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    1646 <handle_syscalls+0x496>
mov    -0x8(%rbp),%edi
lea    -0x58(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    1635 <handle_syscalls+0x485>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    15fb <handle_syscalls+0x44b>
mov    -0x50(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x58(%rbp),%edx
call   10b0 <open@plt>
mov    %eax,-0x5c(%rbp)
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    16ab <handle_syscalls+0x4fb>
mov    -0x8(%rbp),%edi
lea    -0x5c(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1050 <write@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    169a <handle_syscalls+0x4ea>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1660 <handle_syscalls+0x4b0>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
jmp    1b4e <handle_syscalls+0x99e>
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    170c <handle_syscalls+0x55c>
mov    -0x8(%rbp),%edi
lea    -0x60(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    16fb <handle_syscalls+0x54b>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    16c1 <handle_syscalls+0x511>
cmpl   $0x2,-0x60(%rbp)
jle    1726 <handle_syscalls+0x576>
mov    -0x60(%rbp),%edi
call   1070 <close@plt>
mov    %eax,-0x64(%rbp)
jmp    172d <handle_syscalls+0x57d>
movl   $0x0,-0x64(%rbp)
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    1780 <handle_syscalls+0x5d0>
mov    -0x8(%rbp),%edi
lea    -0x64(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1050 <write@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    176f <handle_syscalls+0x5bf>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1735 <handle_syscalls+0x585>
jmp    1b4e <handle_syscalls+0x99e>
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    17d8 <handle_syscalls+0x628>
mov    -0x8(%rbp),%edi
lea    -0x68(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    17c7 <handle_syscalls+0x617>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    178d <handle_syscalls+0x5dd>
movq   $0x0,-0x20(%rbp)
cmpq   $0x8,-0x20(%rbp)
jae    182b <handle_syscalls+0x67b>
mov    -0x8(%rbp),%edi
lea    -0x78(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x8,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    181a <handle_syscalls+0x66a>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    17e0 <handle_syscalls+0x630>
mov    -0x78(%rbp),%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x88(%rbp)
cmpq   $0x0,-0x88(%rbp)
jne    184e <handle_syscalls+0x69e>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x68(%rbp),%edi
mov    -0x88(%rbp),%rsi
mov    -0x78(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x8(%rbp),%edi
mov    0x2768(%rip),%rax
mov    (%rax),%esi
mov    0x2767(%rip),%rax
mov    (%rax),%edx
lea    -0x6c(%rbp),%rcx
mov    $0x4,%r8d
call   1040 <setsockopt@plt>
movq   $0x0,-0x20(%rbp)
cmpq   $0x8,-0x20(%rbp)
jae    18e5 <handle_syscalls+0x735>
mov    -0x8(%rbp),%edi
lea    -0x80(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x8,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1050 <write@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    18d4 <handle_syscalls+0x724>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    189a <handle_syscalls+0x6ea>
cmpq   $0x0,-0x80(%rbp)
jle    195f <handle_syscalls+0x7af>
movq   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x80(%rbp),%rax
jae    195a <handle_syscalls+0x7aa>
mov    -0x8(%rbp),%edi
mov    -0x88(%rbp),%rsi
add    -0x90(%rbp),%rsi
mov    -0x80(%rbp),%rax
sub    -0x90(%rbp),%rax
mov    %eax,%edx
call   1050 <write@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    1943 <handle_syscalls+0x793>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x90(%rbp),%rax
mov    %rax,-0x90(%rbp)
jmp    18fb <handle_syscalls+0x74b>
jmp    195f <handle_syscalls+0x7af>
movl   $0x1,-0x6c(%rbp)
mov    -0x8(%rbp),%edi
mov    0x2670(%rip),%rax
mov    (%rax),%esi
mov    0x266f(%rip),%rax
mov    (%rax),%edx
lea    -0x6c(%rbp),%rcx
mov    $0x4,%r8d
call   1040 <setsockopt@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
jmp    1b4e <handle_syscalls+0x99e>
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    19f1 <handle_syscalls+0x841>
mov    -0x8(%rbp),%edi
lea    -0x94(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    19e0 <handle_syscalls+0x830>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    19a3 <handle_syscalls+0x7f3>
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    1a47 <handle_syscalls+0x897>
mov    -0x8(%rbp),%edi
lea    -0x9c(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    1a36 <handle_syscalls+0x886>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    19f9 <handle_syscalls+0x849>
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    1a9d <handle_syscalls+0x8ed>
mov    -0x8(%rbp),%edi
lea    -0x98(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1080 <read@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    1a8c <handle_syscalls+0x8dc>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1a4f <handle_syscalls+0x89f>
mov    -0x94(%rbp),%edi
mov    -0x9c(%rbp),%esi
mov    -0x98(%rbp),%edx
call   1060 <lseek@plt>
mov    %eax,-0x9c(%rbp)
movq   $0x0,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jae    1b10 <handle_syscalls+0x960>
mov    -0x8(%rbp),%edi
lea    -0x9c(%rbp),%rsi
add    -0x20(%rbp),%rsi
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %eax,%edx
call   1050 <write@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    1aff <handle_syscalls+0x94f>
jmp    1b53 <handle_syscalls+0x9a3>
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1ac2 <handle_syscalls+0x912>
jmp    1b4e <handle_syscalls+0x99e>
mov    0x24b4(%rip),%rax
mov    (%rax),%edi
mov    -0xc(%rbp),%edx
mov    0x24a0(%rip),%rax
mov    (%rax),%ecx
mov    -0x18(%rbp),%r8
lea    0x522(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%edi
call   1070 <close@plt>
mov    $0x1,%edi
call   10d0 <exit@plt>
jmp    11be <handle_syscalls+0xe>
lea    0x532(%rip),%rdi
call   10c0 <perror@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<handle_syscalls>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edi,%r13d
xor    %ebp,%ebp
lea    0xe36(%rip),%r14
nopw   0x0(%rax,%rax,1)
lea    (%rsp,%rbp,1),%rsi
add    $0x34,%rsi
mov    $0x4,%edx
sub    %ebp,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbp
cmp    $0x3,%rbp
jbe    11d0 <handle_syscalls+0x20>
mov    0x34(%rsp),%edx
cmp    $0x5,%rdx
ja     1849 <handle_syscalls+0x699>
movslq (%r14,%rdx,4),%rax
add    %r14,%rax
jmp    *%rax
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
lea    (%rsp,%rbx,1),%rsi
add    $0x18,%rsi
mov    $0x8,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x7,%rbx
jbe    1220 <handle_syscalls+0x70>
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
call   10a0 <malloc@plt>
test   %rax,%rax
je     1829 <handle_syscalls+0x679>
mov    %rax,%r15
test   %rbp,%rbp
je     1296 <handle_syscalls+0xe6>
xor    %ebx,%ebx
xchg   %ax,%ax
lea    (%r15,%rbx,1),%rsi
mov    %ebp,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    %rbx,%rbp
ja     1270 <handle_syscalls+0xc0>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%rsp,%rbx,1),%rsi
add    $0x28,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x4,%rbx
jb     12a0 <handle_syscalls+0xf0>
xor    %ebx,%ebx
lea    (%rsp,%rbx,1),%rsi
add    $0x14,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x3,%rbx
jbe    12d0 <handle_syscalls+0x120>
mov    0x28(%rsp),%esi
mov    0x14(%rsp),%edx
mov    %r15,%rdi
call   10b0 <open@plt>
mov    %eax,0x24(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rsp,%rbx,1),%rsi
add    $0x24,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1050 <write@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x3,%rbx
jbe    1320 <handle_syscalls+0x170>
jmp    1544 <handle_syscalls+0x394>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsp,%rbx,1),%rsi
add    $0x18,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x3,%rbx
jbe    1360 <handle_syscalls+0x1b0>
mov    0x18(%rsp),%edi
xor    %eax,%eax
cmp    $0x3,%edi
jl     139e <handle_syscalls+0x1ee>
call   1070 <close@plt>
mov    %eax,0x28(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rsp,%rbx,1),%rsi
add    $0x28,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1050 <write@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x3,%rbx
jbe    13b0 <handle_syscalls+0x200>
xor    %ebp,%ebp
jmp    11d0 <handle_syscalls+0x20>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
lea    (%rsp,%rbx,1),%rsi
add    $0x14,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x4,%rbx
jb     13f0 <handle_syscalls+0x240>
xor    %ebx,%ebx
lea    (%rsp,%rbx,1),%rsi
add    $0x18,%rsi
mov    $0x8,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x7,%rbx
jbe    1420 <handle_syscalls+0x270>
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
call   10a0 <malloc@plt>
test   %rax,%rax
je     1829 <handle_syscalls+0x679>
mov    %rax,%r15
mov    0x14(%rsp),%edi
mov    %rax,%rsi
mov    %ebp,%edx
call   1080 <read@plt>
mov    %rax,%r12
mov    %rax,0x28(%rsp)
movl   $0x0,0x24(%rsp)
mov    0x2b54(%rip),%rax
mov    (%rax),%esi
mov    0x2b53(%rip),%rax
mov    (%rax),%edx
mov    %r13d,%edi
lea    0x24(%rsp),%rcx
mov    $0x4,%r8d
call   1040 <setsockopt@plt>
xor    %ebx,%ebx
nopl   0x0(%rax)
lea    (%rsp,%rbx,1),%rsi
add    $0x28,%rsi
mov    $0x8,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1050 <write@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x7,%rbx
jbe    14b0 <handle_syscalls+0x300>
test   %r12,%r12
jle    1517 <handle_syscalls+0x367>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r15,%rbx,1),%rsi
mov    %r12d,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1050 <write@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    %rbx,%r12
ja     14f0 <handle_syscalls+0x340>
movl   $0x1,0x24(%rsp)
mov    0x2aba(%rip),%rax
mov    (%rax),%esi
mov    0x2ab9(%rip),%rax
mov    (%rax),%edx
mov    %r13d,%edi
lea    0x24(%rsp),%rcx
mov    $0x4,%r8d
call   1040 <setsockopt@plt>
mov    %r15,%rdi
call   1030 <free@plt>
xor    %ebp,%ebp
jmp    11d0 <handle_syscalls+0x20>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsp,%rbx,1),%rsi
add    $0x18,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x4,%rbx
jb     1560 <handle_syscalls+0x3b0>
xor    %ebx,%ebx
lea    (%rsp,%rbx,1),%rsi
add    $0x14,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x4,%rbx
jb     1590 <handle_syscalls+0x3e0>
xor    %ebx,%ebx
lea    (%rsp,%rbx,1),%rsi
add    $0x28,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x3,%rbx
jbe    15c0 <handle_syscalls+0x410>
mov    0x18(%rsp),%edi
mov    0x14(%rsp),%esi
mov    0x28(%rsp),%edx
call   1060 <lseek@plt>
mov    %eax,0x14(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsp,%rbx,1),%rsi
add    $0x14,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1050 <write@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x3,%rbx
jbe    1610 <handle_syscalls+0x460>
xor    %ebp,%ebp
jmp    11d0 <handle_syscalls+0x20>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rsp,%rbx,1),%rsi
add    $0x28,%rsi
mov    $0x4,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x4,%rbx
jb     1660 <handle_syscalls+0x4b0>
xor    %ebx,%ebx
lea    (%rsp,%rbx,1),%rsi
add    $0x18,%rsi
mov    $0x8,%edx
sub    %ebx,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbx
cmp    $0x7,%rbx
jbe    1690 <handle_syscalls+0x4e0>
mov    0x18(%rsp),%r12
mov    %r12,%rdi
call   10a0 <malloc@plt>
test   %rax,%rax
je     17ad <handle_syscalls+0x5fd>
mov    %rax,%r15
test   %r12,%r12
je     1749 <handle_syscalls+0x599>
xor    %ebp,%ebp
xchg   %ax,%ax
lea    (%r15,%rbp,1),%rsi
mov    %r12d,%edx
sub    %ebp,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbp
cmp    %rbp,%r12
ja     16e0 <handle_syscalls+0x530>
mov    0x28(%rsp),%ebp
cmp    $0x2,%ebp
jg     1752 <handle_syscalls+0x5a2>
test   %r12,%r12
je     17a0 <handle_syscalls+0x5f0>
xor    %r14d,%r14d
nopl   0x0(%rax)
lea    (%r15,%r14,1),%rsi
mov    %r12d,%edx
sub    %r14d,%edx
mov    %ebp,%edi
call   1050 <write@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%r14
cmp    %r14,%r12
ja     1720 <handle_syscalls+0x570>
jmp    17a0 <handle_syscalls+0x5f0>
mov    0x28(%rsp),%ebp
cmp    $0x2,%ebp
jle    17a0 <handle_syscalls+0x5f0>
mov    %ebp,%edi
mov    %r15,%rsi
mov    %r12d,%edx
call   1050 <write@plt>
mov    %rax,0x8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
cmp    $0x7,%rbp
ja     17a0 <handle_syscalls+0x5f0>
lea    (%rsp,%rbp,1),%rsi
add    $0x8,%rsi
mov    $0x8,%edx
sub    %ebp,%edx
mov    %r13d,%edi
call   1050 <write@plt>
cltq
add    %rax,%rbp
test   $0x80000000,%eax
je     1770 <handle_syscalls+0x5c0>
jmp    1829 <handle_syscalls+0x679>
xchg   %ax,%ax
mov    %r15,%rdi
call   1030 <free@plt>
jmp    11c1 <handle_syscalls+0x11>
mov    0x281c(%rip),%rax
mov    (%rax),%edi
lea    0x881(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
jmp    1835 <handle_syscalls+0x685>
movl   $0x0,0x18(%rsp)
xor    %ebp,%ebp
lea    (%rsp,%rbp,1),%rsi
add    $0x18,%rsi
mov    $0x4,%edx
sub    %ebp,%edx
mov    %r13d,%edi
call   1080 <read@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
js     1829 <handle_syscalls+0x679>
add    %rax,%rbp
cmp    $0x3,%rbp
jbe    17d0 <handle_syscalls+0x620>
mov    %r13d,%edi
call   1070 <close@plt>
mov    0x18(%rsp),%ebx
cmp    $0xfffffff2,%ebx
jne    1822 <handle_syscalls+0x672>
mov    0x27be(%rip),%rax
mov    (%rax),%edi
lea    0x7fd(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    %ebx,%edi
call   10d0 <exit@plt>
lea    0x85c(%rip),%rdi
call   10c0 <perror@plt>
mov    $0x1,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2780(%rip),%rcx
mov    (%rcx),%edi
mov    0x276f(%rip),%rcx
mov    (%rcx),%ecx
lea    0x7f5(%rip),%rsi
mov    %rax,%r8
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    %r13d,%edi
call   1070 <close@plt>
mov    $0x1,%edi
call   10d0 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [38 x i8] c"Did HermitCore receive an exception?\0A\00"
@.str.1 = [25 x i8] c"Proxy: not enough memory\00"
@IPPROTO_TCP = global i32 0
@TCP_NODELAY = global i32 0
@.str.2 = [53 x i8] c"Proxy: invalid syscall number %d, errno %d, ret %zd\0A\00"
@errno = global i32 0
@.str.3 = [29 x i8] c"Proxy -- communication error\00"
define i32 @handle_syscalls(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i64
%6 = alloca i64
%7 = alloca i32
%8 = alloca i32
%9 = alloca i64
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i64
%13 = alloca i8*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i64
%22 = alloca i64
%23 = alloca i8*
%24 = alloca i64
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
store i32 %0, i32* %3
br label %28
28: ; preds = %1, %582
store i64 0, i64* %6
br label %29
29: ; preds = %44, %28
%30 = load i64, i64* %6
%31 = icmp ult i64 %30, 4
br i1 %31, label %32, label %48
32: ; preds = %29
%33 = load i32, i32* %3
%34 = bitcast i32* %4 to i8*
%35 = load i64, i64* %6
%36 = getelementptr inbounds i8, i8* %34, i64 %35
%37 = load i64, i64* %6
%38 = sub i64 4, %37
%39 = trunc i64 %38 to i32
%40 = call i64 @read(i32 %33, i8* %36, i32 %39)
store i64 %40, i64* %5
%41 = load i64, i64* %5
%42 = icmp slt i64 %41, 0
br i1 %42, label %43, label %44
43: ; preds = %32
br label %583
44: ; preds = %32
%45 = load i64, i64* %5
%46 = load i64, i64* %6
%47 = add i64 %46, %45
store i64 %47, i64* %6
br label %29
48: ; preds = %29
%49 = load i32, i32* %4
switch i32 %49, label %573 [
i32 0, label %50
i32 1, label %81
i32 2, label %210
i32 3, label %326
i32 4, label %375
i32 5, label %487
]
50: ; preds = %48
store i32 0, i32* %7
store i64 0, i64* %6
br label %51
51: ; preds = %66, %50
%52 = load i64, i64* %6
%53 = icmp ult i64 %52, 4
br i1 %53, label %54, label %70
54: ; preds = %51
%55 = load i32, i32* %3
%56 = bitcast i32* %7 to i8*
%57 = load i64, i64* %6
%58 = getelementptr inbounds i8, i8* %56, i64 %57
%59 = load i64, i64* %6
%60 = sub i64 4, %59
%61 = trunc i64 %60 to i32
%62 = call i64 @read(i32 %55, i8* %58, i32 %61)
store i64 %62, i64* %5
%63 = load i64, i64* %5
%64 = icmp slt i64 %63, 0
br i1 %64, label %65, label %66
65: ; preds = %54
br label %583
66: ; preds = %54
%67 = load i64, i64* %5
%68 = load i64, i64* %6
%69 = add i64 %68, %67
store i64 %69, i64* %6
br label %51
70: ; preds = %51
%71 = load i32, i32* %3
%72 = call i32 @close(i32 %71)
%73 = load i32, i32* %7
%74 = icmp eq i32 %73, -14
br i1 %74, label %75, label %78
75: ; preds = %70
%76 = load i32, i32* @stderr
%77 = call i32 (i32, i8*, ...) @fprintf(i32 %76, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
br label %78
78: ; preds = %75, %70
%79 = load i32, i32* %7
%80 = call i32 @exit(i32 %79)
unreachable
81: ; preds = %48
store i64 0, i64* %6
br label %82
82: ; preds = %97, %81
%83 = load i64, i64* %6
%84 = icmp ult i64 %83, 4
br i1 %84, label %85, label %101
85: ; preds = %82
%86 = load i32, i32* %3
%87 = bitcast i32* %8 to i8*
%88 = load i64, i64* %6
%89 = getelementptr inbounds i8, i8* %87, i64 %88
%90 = load i64, i64* %6
%91 = sub i64 4, %90
%92 = trunc i64 %91 to i32
%93 = call i64 @read(i32 %86, i8* %89, i32 %92)
store i64 %93, i64* %5
%94 = load i64, i64* %5
%95 = icmp slt i64 %94, 0
br i1 %95, label %96, label %97
96: ; preds = %85
br label %583
97: ; preds = %85
%98 = load i64, i64* %5
%99 = load i64, i64* %6
%100 = add i64 %99, %98
store i64 %100, i64* %6
br label %82
101: ; preds = %82
store i64 0, i64* %6
br label %102
102: ; preds = %117, %101
%103 = load i64, i64* %6
%104 = icmp ult i64 %103, 8
br i1 %104, label %105, label %121
105: ; preds = %102
%106 = load i32, i32* %3
%107 = bitcast i64* %9 to i8*
%108 = load i64, i64* %6
%109 = getelementptr inbounds i8, i8* %107, i64 %108
%110 = load i64, i64* %6
%111 = sub i64 8, %110
%112 = trunc i64 %111 to i32
%113 = call i64 @read(i32 %106, i8* %109, i32 %112)
store i64 %113, i64* %5
%114 = load i64, i64* %5
%115 = icmp slt i64 %114, 0
br i1 %115, label %116, label %117
116: ; preds = %105
br label %583
117: ; preds = %105
%118 = load i64, i64* %5
%119 = load i64, i64* %6
%120 = add i64 %119, %118
store i64 %120, i64* %6
br label %102
121: ; preds = %102
%122 = load i64, i64* %9
%123 = call i8* @malloc(i64 %122)
store i8* %123, i8** %10
%124 = load i8*, i8** %10
%125 = icmp ne i8* %124, null
br i1 %125, label %129, label %126
126: ; preds = %121
%127 = load i32, i32* @stderr
%128 = call i32 (i32, i8*, ...) @fprintf(i32 %127, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %2
br label %585
129: ; preds = %121
store i64 0, i64* %6
br label %130
130: ; preds = %147, %129
%131 = load i64, i64* %6
%132 = load i64, i64* %9
%133 = icmp ult i64 %131, %132
br i1 %133, label %134, label %151
134: ; preds = %130
%135 = load i32, i32* %3
%136 = load i8*, i8** %10
%137 = load i64, i64* %6
%138 = getelementptr inbounds i8, i8* %136, i64 %137
%139 = load i64, i64* %9
%140 = load i64, i64* %6
%141 = sub i64 %139, %140
%142 = trunc i64 %141 to i32
%143 = call i64 @read(i32 %135, i8* %138, i32 %142)
store i64 %143, i64* %5
%144 = load i64, i64* %5
%145 = icmp slt i64 %144, 0
br i1 %145, label %146, label %147
146: ; preds = %134
br label %583
147: ; preds = %134
%148 = load i64, i64* %5
%149 = load i64, i64* %6
%150 = add i64 %149, %148
store i64 %150, i64* %6
br label %130
151: ; preds = %130
%152 = load i32, i32* %8
%153 = icmp sgt i32 %152, 2
br i1 %153, label %154, label %183
154: ; preds = %151
%155 = load i32, i32* %8
%156 = load i8*, i8** %10
%157 = load i64, i64* %9
%158 = trunc i64 %157 to i32
%159 = call i8* @write(i32 %155, i8* %156, i32 %158)
%160 = ptrtoint i8* %159 to i64
store i64 %160, i64* %5
store i64 0, i64* %6
br label %161
161: ; preds = %177, %154
%162 = load i64, i64* %6
%163 = icmp ult i64 %162, 8
br i1 %163, label %164, label %182
164: ; preds = %161
%165 = load i32, i32* %3
%166 = bitcast i64* %5 to i8*
%167 = load i64, i64* %6
%168 = getelementptr inbounds i8, i8* %166, i64 %167
%169 = load i64, i64* %6
%170 = sub i64 8, %169
%171 = trunc i64 %170 to i32
%172 = call i8* @write(i32 %165, i8* %168, i32 %171)
%173 = ptrtoint i8* %172 to i32
store i32 %173, i32* %11
%174 = load i32, i32* %11
%175 = icmp slt i32 %174, 0
br i1 %175, label %176, label %177
176: ; preds = %164
br label %583
177: ; preds = %164
%178 = load i32, i32* %11
%179 = sext i32 %178 to i64
%180 = load i64, i64* %6
%181 = add i64 %180, %179
store i64 %181, i64* %6
br label %161
182: ; preds = %161
br label %207
183: ; preds = %151
store i64 0, i64* %6
br label %184
184: ; preds = %202, %183
%185 = load i64, i64* %6
%186 = load i64, i64* %9
%187 = icmp ult i64 %185, %186
br i1 %187, label %188, label %206
188: ; preds = %184
%189 = load i32, i32* %8
%190 = load i8*, i8** %10
%191 = load i64, i64* %6
%192 = getelementptr inbounds i8, i8* %190, i64 %191
%193 = load i64, i64* %9
%194 = load i64, i64* %6
%195 = sub i64 %193, %194
%196 = trunc i64 %195 to i32
%197 = call i8* @write(i32 %189, i8* %192, i32 %196)
%198 = ptrtoint i8* %197 to i64
store i64 %198, i64* %5
%199 = load i64, i64* %5
%200 = icmp slt i64 %199, 0
br i1 %200, label %201, label %202
201: ; preds = %188
br label %583
202: ; preds = %188
%203 = load i64, i64* %5
%204 = load i64, i64* %6
%205 = add i64 %204, %203
store i64 %205, i64* %6
br label %184
206: ; preds = %184
br label %207
207: ; preds = %206, %182
%208 = load i8*, i8** %10
%209 = call i32 @free(i8* %208)
br label %582
210: ; preds = %48
store i64 0, i64* %6
br label %211
211: ; preds = %226, %210
%212 = load i64, i64* %6
%213 = icmp ult i64 %212, 8
br i1 %213, label %214, label %230
214: ; preds = %211
%215 = load i32, i32* %3
%216 = bitcast i64* %12 to i8*
%217 = load i64, i64* %6
%218 = getelementptr inbounds i8, i8* %216, i64 %217
%219 = load i64, i64* %6
%220 = sub i64 8, %219
%221 = trunc i64 %220 to i32
%222 = call i64 @read(i32 %215, i8* %218, i32 %221)
store i64 %222, i64* %5
%223 = load i64, i64* %5
%224 = icmp slt i64 %223, 0
br i1 %224, label %225, label %226
225: ; preds = %214
br label %583
226: ; preds = %214
%227 = load i64, i64* %5
%228 = load i64, i64* %6
%229 = add i64 %228, %227
store i64 %229, i64* %6
br label %211
230: ; preds = %211
%231 = load i64, i64* %12
%232 = call i8* @malloc(i64 %231)
store i8* %232, i8** %13
%233 = load i8*, i8** %13
%234 = icmp ne i8* %233, null
br i1 %234, label %236, label %235
235: ; preds = %230
br label %583
236: ; preds = %230
store i64 0, i64* %6
br label %237
237: ; preds = %254, %236
%238 = load i64, i64* %6
%239 = load i64, i64* %12
%240 = icmp ult i64 %238, %239
br i1 %240, label %241, label %258
241: ; preds = %237
%242 = load i32, i32* %3
%243 = load i8*, i8** %13
%244 = load i64, i64* %6
%245 = getelementptr inbounds i8, i8* %243, i64 %244
%246 = load i64, i64* %12
%247 = load i64, i64* %6
%248 = sub i64 %246, %247
%249 = trunc i64 %248 to i32
%250 = call i64 @read(i32 %242, i8* %245, i32 %249)
store i64 %250, i64* %5
%251 = load i64, i64* %5
%252 = icmp slt i64 %251, 0
br i1 %252, label %253, label %254
253: ; preds = %241
br label %583
254: ; preds = %241
%255 = load i64, i64* %5
%256 = load i64, i64* %6
%257 = add i64 %256, %255
store i64 %257, i64* %6
br label %237
258: ; preds = %237
store i64 0, i64* %6
br label %259
259: ; preds = %274, %258
%260 = load i64, i64* %6
%261 = icmp ult i64 %260, 4
br i1 %261, label %262, label %278
262: ; preds = %259
%263 = load i32, i32* %3
%264 = bitcast i32* %14 to i8*
%265 = load i64, i64* %6
%266 = getelementptr inbounds i8, i8* %264, i64 %265
%267 = load i64, i64* %6
%268 = sub i64 4, %267
%269 = trunc i64 %268 to i32
%270 = call i64 @read(i32 %263, i8* %266, i32 %269)
store i64 %270, i64* %5
%271 = load i64, i64* %5
%272 = icmp slt i64 %271, 0
br i1 %272, label %273, label %274
273: ; preds = %262
br label %583
274: ; preds = %262
%275 = load i64, i64* %5
%276 = load i64, i64* %6
%277 = add i64 %276, %275
store i64 %277, i64* %6
br label %259
278: ; preds = %259
store i64 0, i64* %6
br label %279
279: ; preds = %294, %278
%280 = load i64, i64* %6
%281 = icmp ult i64 %280, 4
br i1 %281, label %282, label %298
282: ; preds = %279
%283 = load i32, i32* %3
%284 = bitcast i32* %15 to i8*
%285 = load i64, i64* %6
%286 = getelementptr inbounds i8, i8* %284, i64 %285
%287 = load i64, i64* %6
%288 = sub i64 4, %287
%289 = trunc i64 %288 to i32
%290 = call i64 @read(i32 %283, i8* %286, i32 %289)
store i64 %290, i64* %5
%291 = load i64, i64* %5
%292 = icmp slt i64 %291, 0
br i1 %292, label %293, label %294
293: ; preds = %282
br label %583
294: ; preds = %282
%295 = load i64, i64* %5
%296 = load i64, i64* %6
%297 = add i64 %296, %295
store i64 %297, i64* %6
br label %279
298: ; preds = %279
%299 = load i8*, i8** %13
%300 = load i32, i32* %14
%301 = load i32, i32* %15
%302 = call i32 @open(i8* %299, i32 %300, i32 %301)
store i32 %302, i32* %16
store i64 0, i64* %6
br label %303
303: ; preds = %319, %298
%304 = load i64, i64* %6
%305 = icmp ult i64 %304, 4
br i1 %305, label %306, label %323
306: ; preds = %303
%307 = load i32, i32* %3
%308 = bitcast i32* %16 to i8*
%309 = load i64, i64* %6
%310 = getelementptr inbounds i8, i8* %308, i64 %309
%311 = load i64, i64* %6
%312 = sub i64 4, %311
%313 = trunc i64 %312 to i32
%314 = call i8* @write(i32 %307, i8* %310, i32 %313)
%315 = ptrtoint i8* %314 to i64
store i64 %315, i64* %5
%316 = load i64, i64* %5
%317 = icmp slt i64 %316, 0
br i1 %317, label %318, label %319
318: ; preds = %306
br label %583
319: ; preds = %306
%320 = load i64, i64* %5
%321 = load i64, i64* %6
%322 = add i64 %321, %320
store i64 %322, i64* %6
br label %303
323: ; preds = %303
%324 = load i8*, i8** %13
%325 = call i32 @free(i8* %324)
br label %582
326: ; preds = %48
store i64 0, i64* %6
br label %327
327: ; preds = %342, %326
%328 = load i64, i64* %6
%329 = icmp ult i64 %328, 4
br i1 %329, label %330, label %346
330: ; preds = %327
%331 = load i32, i32* %3
%332 = bitcast i32* %17 to i8*
%333 = load i64, i64* %6
%334 = getelementptr inbounds i8, i8* %332, i64 %333
%335 = load i64, i64* %6
%336 = sub i64 4, %335
%337 = trunc i64 %336 to i32
%338 = call i64 @read(i32 %331, i8* %334, i32 %337)
store i64 %338, i64* %5
%339 = load i64, i64* %5
%340 = icmp slt i64 %339, 0
br i1 %340, label %341, label %342
341: ; preds = %330
br label %583
342: ; preds = %330
%343 = load i64, i64* %5
%344 = load i64, i64* %6
%345 = add i64 %344, %343
store i64 %345, i64* %6
br label %327
346: ; preds = %327
%347 = load i32, i32* %17
%348 = icmp sgt i32 %347, 2
br i1 %348, label %349, label %352
349: ; preds = %346
%350 = load i32, i32* %17
%351 = call i32 @close(i32 %350)
store i32 %351, i32* %18
br label %353
352: ; preds = %346
store i32 0, i32* %18
br label %353
353: ; preds = %352, %349
store i64 0, i64* %6
br label %354
354: ; preds = %370, %353
%355 = load i64, i64* %6
%356 = icmp ult i64 %355, 4
br i1 %356, label %357, label %374
357: ; preds = %354
%358 = load i32, i32* %3
%359 = bitcast i32* %18 to i8*
%360 = load i64, i64* %6
%361 = getelementptr inbounds i8, i8* %359, i64 %360
%362 = load i64, i64* %6
%363 = sub i64 4, %362
%364 = trunc i64 %363 to i32
%365 = call i8* @write(i32 %358, i8* %361, i32 %364)
%366 = ptrtoint i8* %365 to i64
store i64 %366, i64* %5
%367 = load i64, i64* %5
%368 = icmp slt i64 %367, 0
br i1 %368, label %369, label %370
369: ; preds = %357
br label %583
370: ; preds = %357
%371 = load i64, i64* %5
%372 = load i64, i64* %6
%373 = add i64 %372, %371
store i64 %373, i64* %6
br label %354
374: ; preds = %354
br label %582
375: ; preds = %48
store i64 0, i64* %6
br label %376
376: ; preds = %391, %375
%377 = load i64, i64* %6
%378 = icmp ult i64 %377, 4
br i1 %378, label %379, label %395
379: ; preds = %376
%380 = load i32, i32* %3
%381 = bitcast i32* %19 to i8*
%382 = load i64, i64* %6
%383 = getelementptr inbounds i8, i8* %381, i64 %382
%384 = load i64, i64* %6
%385 = sub i64 4, %384
%386 = trunc i64 %385 to i32
%387 = call i64 @read(i32 %380, i8* %383, i32 %386)
store i64 %387, i64* %5
%388 = load i64, i64* %5
%389 = icmp slt i64 %388, 0
br i1 %389, label %390, label %391
390: ; preds = %379
br label %583
391: ; preds = %379
%392 = load i64, i64* %5
%393 = load i64, i64* %6
%394 = add i64 %393, %392
store i64 %394, i64* %6
br label %376
395: ; preds = %376
store i64 0, i64* %6
br label %396
396: ; preds = %411, %395
%397 = load i64, i64* %6
%398 = icmp ult i64 %397, 8
br i1 %398, label %399, label %415
399: ; preds = %396
%400 = load i32, i32* %3
%401 = bitcast i64* %21 to i8*
%402 = load i64, i64* %6
%403 = getelementptr inbounds i8, i8* %401, i64 %402
%404 = load i64, i64* %6
%405 = sub i64 8, %404
%406 = trunc i64 %405 to i32
%407 = call i64 @read(i32 %400, i8* %403, i32 %406)
store i64 %407, i64* %5
%408 = load i64, i64* %5
%409 = icmp slt i64 %408, 0
br i1 %409, label %410, label %411
410: ; preds = %399
br label %583
411: ; preds = %399
%412 = load i64, i64* %5
%413 = load i64, i64* %6
%414 = add i64 %413, %412
store i64 %414, i64* %6
br label %396
415: ; preds = %396
%416 = load i64, i64* %21
%417 = call i8* @malloc(i64 %416)
store i8* %417, i8** %23
%418 = load i8*, i8** %23
%419 = icmp ne i8* %418, null
br i1 %419, label %421, label %420
420: ; preds = %415
br label %583
421: ; preds = %415
%422 = load i32, i32* %19
%423 = load i8*, i8** %23
%424 = load i64, i64* %21
%425 = trunc i64 %424 to i32
%426 = call i64 @read(i32 %422, i8* %423, i32 %425)
store i64 %426, i64* %22
store i32 0, i32* %20
%427 = load i32, i32* %3
%428 = load i32, i32* @IPPROTO_TCP
%429 = load i32, i32* @TCP_NODELAY
%430 = bitcast i32* %20 to i8*
%431 = call i32 @setsockopt(i32 %427, i32 %428, i32 %429, i8* %430, i32 4)
store i64 0, i64* %6
br label %432
432: ; preds = %448, %421
%433 = load i64, i64* %6
%434 = icmp ult i64 %433, 8
br i1 %434, label %435, label %452
435: ; preds = %432
%436 = load i32, i32* %3
%437 = bitcast i64* %22 to i8*
%438 = load i64, i64* %6
%439 = getelementptr inbounds i8, i8* %437, i64 %438
%440 = load i64, i64* %6
%441 = sub i64 8, %440
%442 = trunc i64 %441 to i32
%443 = call i8* @write(i32 %436, i8* %439, i32 %442)
%444 = ptrtoint i8* %443 to i64
store i64 %444, i64* %5
%445 = load i64, i64* %5
%446 = icmp slt i64 %445, 0
br i1 %446, label %447, label %448
447: ; preds = %435
br label %583
448: ; preds = %435
%449 = load i64, i64* %5
%450 = load i64, i64* %6
%451 = add i64 %450, %449
store i64 %451, i64* %6
br label %432
452: ; preds = %432
%453 = load i64, i64* %22
%454 = icmp sgt i64 %453, 0
br i1 %454, label %455, label %479
455: ; preds = %452
store i64 0, i64* %24
br label %456
456: ; preds = %474, %455
%457 = load i64, i64* %24
%458 = load i64, i64* %22
%459 = icmp ult i64 %457, %458
br i1 %459, label %460, label %478
460: ; preds = %456
%461 = load i32, i32* %3
%462 = load i8*, i8** %23
%463 = load i64, i64* %24
%464 = getelementptr inbounds i8, i8* %462, i64 %463
%465 = load i64, i64* %22
%466 = load i64, i64* %24
%467 = sub i64 %465, %466
%468 = trunc i64 %467 to i32
%469 = call i8* @write(i32 %461, i8* %464, i32 %468)
%470 = ptrtoint i8* %469 to i64
store i64 %470, i64* %5
%471 = load i64, i64* %5
%472 = icmp slt i64 %471, 0
br i1 %472, label %473, label %474
473: ; preds = %460
br label %583
474: ; preds = %460
%475 = load i64, i64* %5
%476 = load i64, i64* %24
%477 = add i64 %476, %475
store i64 %477, i64* %24
br label %456
478: ; preds = %456
br label %479
479: ; preds = %478, %452
store i32 1, i32* %20
%480 = load i32, i32* %3
%481 = load i32, i32* @IPPROTO_TCP
%482 = load i32, i32* @TCP_NODELAY
%483 = bitcast i32* %20 to i8*
%484 = call i32 @setsockopt(i32 %480, i32 %481, i32 %482, i8* %483, i32 4)
%485 = load i8*, i8** %23
%486 = call i32 @free(i8* %485)
br label %582
487: ; preds = %48
store i64 0, i64* %6
br label %488
488: ; preds = %503, %487
%489 = load i64, i64* %6
%490 = icmp ult i64 %489, 4
br i1 %490, label %491, label %507
491: ; preds = %488
%492 = load i32, i32* %3
%493 = bitcast i32* %25 to i8*
%494 = load i64, i64* %6
%495 = getelementptr inbounds i8, i8* %493, i64 %494
%496 = load i64, i64* %6
%497 = sub i64 4, %496
%498 = trunc i64 %497 to i32
%499 = call i64 @read(i32 %492, i8* %495, i32 %498)
store i64 %499, i64* %5
%500 = load i64, i64* %5
%501 = icmp slt i64 %500, 0
br i1 %501, label %502, label %503
502: ; preds = %491
br label %583
503: ; preds = %491
%504 = load i64, i64* %5
%505 = load i64, i64* %6
%506 = add i64 %505, %504
store i64 %506, i64* %6
br label %488
507: ; preds = %488
store i64 0, i64* %6
br label %508
508: ; preds = %523, %507
%509 = load i64, i64* %6
%510 = icmp ult i64 %509, 4
br i1 %510, label %511, label %527
511: ; preds = %508
%512 = load i32, i32* %3
%513 = bitcast i32* %27 to i8*
%514 = load i64, i64* %6
%515 = getelementptr inbounds i8, i8* %513, i64 %514
%516 = load i64, i64* %6
%517 = sub i64 4, %516
%518 = trunc i64 %517 to i32
%519 = call i64 @read(i32 %512, i8* %515, i32 %518)
store i64 %519, i64* %5
%520 = load i64, i64* %5
%521 = icmp slt i64 %520, 0
br i1 %521, label %522, label %523
522: ; preds = %511
br label %583
523: ; preds = %511
%524 = load i64, i64* %5
%525 = load i64, i64* %6
%526 = add i64 %525, %524
store i64 %526, i64* %6
br label %508
527: ; preds = %508
store i64 0, i64* %6
br label %528
528: ; preds = %543, %527
%529 = load i64, i64* %6
%530 = icmp ult i64 %529, 4
br i1 %530, label %531, label %547
531: ; preds = %528
%532 = load i32, i32* %3
%533 = bitcast i32* %26 to i8*
%534 = load i64, i64* %6
%535 = getelementptr inbounds i8, i8* %533, i64 %534
%536 = load i64, i64* %6
%537 = sub i64 4, %536
%538 = trunc i64 %537 to i32
%539 = call i64 @read(i32 %532, i8* %535, i32 %538)
store i64 %539, i64* %5
%540 = load i64, i64* %5
%541 = icmp slt i64 %540, 0
br i1 %541, label %542, label %543
542: ; preds = %531
br label %583
543: ; preds = %531
%544 = load i64, i64* %5
%545 = load i64, i64* %6
%546 = add i64 %545, %544
store i64 %546, i64* %6
br label %528
547: ; preds = %528
%548 = load i32, i32* %25
%549 = load i32, i32* %27
%550 = load i32, i32* %26
%551 = call i32 @lseek(i32 %548, i32 %549, i32 %550)
store i32 %551, i32* %27
store i64 0, i64* %6
br label %552
552: ; preds = %568, %547
%553 = load i64, i64* %6
%554 = icmp ult i64 %553, 4
br i1 %554, label %555, label %572
555: ; preds = %552
%556 = load i32, i32* %3
%557 = bitcast i32* %27 to i8*
%558 = load i64, i64* %6
%559 = getelementptr inbounds i8, i8* %557, i64 %558
%560 = load i64, i64* %6
%561 = sub i64 4, %560
%562 = trunc i64 %561 to i32
%563 = call i8* @write(i32 %556, i8* %559, i32 %562)
%564 = ptrtoint i8* %563 to i64
store i64 %564, i64* %5
%565 = load i64, i64* %5
%566 = icmp slt i64 %565, 0
br i1 %566, label %567, label %568
567: ; preds = %555
br label %583
568: ; preds = %555
%569 = load i64, i64* %5
%570 = load i64, i64* %6
%571 = add i64 %570, %569
store i64 %571, i64* %6
br label %552
572: ; preds = %552
br label %582
573: ; preds = %48
%574 = load i32, i32* @stderr
%575 = load i32, i32* %4
%576 = load i32, i32* @errno
%577 = load i64, i64* %5
%578 = call i32 (i32, i8*, ...) @fprintf(i32 %574, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.2, i64 0, i64 0), i32 %575, i32 %576, i64 %577)
%579 = load i32, i32* %3
%580 = call i32 @close(i32 %579)
%581 = call i32 @exit(i32 1)
unreachable
582: ; preds = %572, %479, %374, %323, %207
br label %28
583: ; preds = %567, %542, %522, %502, %473, %447, %420, %410, %390, %369, %341, %318, %293, %273, %253, %235, %225, %201, %176, %146, %116, %96, %65, %43
%584 = call i32 @perror(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %2
br label %585
585: ; preds = %583, %126
%586 = load i32, i32* %2
ret i32 %586
}

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