#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 */

/* Variables and functions */
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(char *, char *, int);
scalar_t__ realloc(char *, int);
int /*<<< orphan*/ strcat(char *, char const *);
int /*<<< orphan*/ strlen(char const *);
char *tparam1(const char *string, char *outstring, int len, const char *up,
              const char *left, int *argp) {
  int c;
  const char *p = string;
  char *op = outstring;
  char *outend;
  int outlen = 0;
  int tem;
  int *old_argp = argp;
  int doleft = 0;
  int doup = 0;
  outend = outstring + len;
  while (1) {
    if (op + 5 >= outend) {
      char *new;
      if (outlen == 0) {
        outlen = len + 40;
        new = (char *)malloc(outlen);
        outend += 40;
        memcpy(new, outstring, op - outstring);
      } else {
        outend += outlen;
        outlen *= 2;
        new = (char *)realloc(outstring, outlen);
      }
      op += new - outstring;
      outend += new - outstring;
      outstring = new;
    }
    c = *p++;
    if (!c)
      break;
    if (c == '%') {
      c = *p++;
      tem = *argp;
      switch (c) {
      case 'd':
        if (tem < 10)
          goto onedigit;
        if (tem < 100)
          goto twodigit;
      case '3':
        if (tem > 999) {
          *op++ = tem / 1000 + '0';
          tem %= 1000;
        }
        *op++ = tem / 100 + '0';
      case '2':
      twodigit:
        tem %= 100;
        *op++ = tem / 10 + '0';
      onedigit:
        *op++ = tem % 10 + '0';
        argp++;
        break;
      case 'C':
        if (tem >= 96) {
          *op++ = tem / 96;
          tem %= 96;
        }
      case '+':
        tem += *p++;
      case '.':
        if (left) {
          while (tem == 0 || tem == '\n' || tem == '\t') {
            tem++;
            if (argp == old_argp)
              doup++, outend -= strlen(up);
            else
              doleft++, outend -= strlen(left);
          }
        }
        *op++ = tem | 0200;
      case 'f':
        argp++;
        break;
      case 'b':
        argp--;
        break;
      case 'r':
        argp[0] = argp[1];
        argp[1] = tem;
        old_argp++;
        break;
      case '>':
        if (argp[0] > *p++)
          argp[0] += *p;
        p++;
        break;
      case 'a':
        tem = p[2] & 0177;
        if (p[1] == 'p')
          tem = argp[tem - 0100];
        if (p[0] == '-')
          argp[0] -= tem;
        else if (p[0] == '+')
          argp[0] += tem;
        else if (p[0] == '*')
          argp[0] *= tem;
        else if (p[0] == '/')
          argp[0] /= tem;
        else
          argp[0] = tem;
        p += 3;
        break;
      case 'i':
        argp[0]++;
        argp[1]++;
        break;
      case '%':
        goto ordinary;
      case 'n':
        argp[0] ^= 0140;
        argp[1] ^= 0140;
        break;
      case 'm':
        argp[0] ^= 0177;
        argp[1] ^= 0177;
        break;
      case 'B':
        argp[0] += 6 * (tem / 10);
        break;
      case 'D':
        argp[0] -= 2 * (tem % 16);
        break;
      }
    } else
    ordinary:
      *op++ = c;
  }
  *op = 0;
  while (doup-- > 0)
    strcat(op, up);
  while (doleft-- > 0)
    strcat(op, left);
  return outstring;
}


x86 assembly (clang, -O0):
<tparam1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
add    $0x5,%rax
cmp    -0x50(%rbp),%rax
jb     1262 <tparam1+0x112>
cmpl   $0x0,-0x54(%rbp)
jne    120a <tparam1+0xba>
mov    -0x14(%rbp),%eax
add    $0x28,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x50(%rbp),%rax
add    $0x28,%rax
mov    %rax,-0x50(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1040 <memcpy@plt>
jmp    1234 <tparam1+0xe4>
mov    -0x54(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x54(%rbp),%esi
call   1060 <realloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1286 <tparam1+0x136>
jmp    1716 <tparam1+0x5c6>
cmpl   $0x25,-0x34(%rbp)
jne    16f6 <tparam1+0x5a6>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffdb,%eax
mov    %eax,%ecx
mov    %rcx,-0x78(%rbp)
sub    $0x4d,%eax
ja     16f1 <tparam1+0x5a1>
mov    -0x78(%rbp),%rax
lea    0xd32(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0xa,-0x58(%rbp)
jge    12e6 <tparam1+0x196>
jmp    138b <tparam1+0x23b>
cmpl   $0x64,-0x58(%rbp)
jge    12f5 <tparam1+0x1a5>
jmp    135c <tparam1+0x20c>
jmp    12fa <tparam1+0x1aa>
cmpl   $0x3e7,-0x58(%rbp)
jle    1336 <tparam1+0x1e6>
mov    -0x58(%rbp),%eax
mov    $0x3e8,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%eax
mov    $0x3e8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    135c <tparam1+0x20c>
mov    -0x58(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %edx,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%eax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    16f1 <tparam1+0x5a1>
cmpl   $0x60,-0x58(%rbp)
jl     13f3 <tparam1+0x2a3>
mov    -0x58(%rbp),%eax
mov    $0x60,%ecx
cltd
idiv   %ecx
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%eax
mov    $0x60,%ecx
cltd
idiv   %ecx
mov    %edx,-0x58(%rbp)
jmp    13f8 <tparam1+0x2a8>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl (%rax),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     14cc <tparam1+0x37c>
jmp    1420 <tparam1+0x2d0>
mov    $0x1,%al
cmpl   $0x0,-0x58(%rbp)
mov    %al,-0x79(%rbp)
je     1448 <tparam1+0x2f8>
mov    $0x1,%al
cmpl   $0xa,-0x58(%rbp)
mov    %al,-0x79(%rbp)
je     1448 <tparam1+0x2f8>
cmpl   $0x9,-0x58(%rbp)
sete   %al
mov    %al,-0x79(%rbp)
mov    -0x79(%rbp),%al
test   $0x1,%al
jne    1458 <tparam1+0x308>
jmp    14c7 <tparam1+0x377>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x60(%rbp),%rax
jne    149b <tparam1+0x34b>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    14c2 <tparam1+0x372>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1420 <tparam1+0x2d0>
jmp    14cc <tparam1+0x37c>
mov    -0x58(%rbp),%eax
or     $0x80,%eax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    16f1 <tparam1+0x5a1>
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
jmp    16f1 <tparam1+0x5a1>
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x60(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x60(%rbp)
jmp    16f1 <tparam1+0x5a1>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jle    1560 <tparam1+0x410>
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
mov    -0x30(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    16f1 <tparam1+0x5a1>
mov    -0x40(%rbp),%rax
movsbl 0x2(%rax),%eax
and    $0x7f,%eax
mov    %eax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x70,%eax
jne    15a3 <tparam1+0x453>
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x40,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    15c5 <tparam1+0x475>
mov    -0x58(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
jmp    1651 <tparam1+0x501>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    15e5 <tparam1+0x495>
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
jmp    164c <tparam1+0x4fc>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    1606 <tparam1+0x4b6>
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
imul   (%rax),%ecx
mov    %ecx,(%rax)
jmp    1647 <tparam1+0x4f7>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    1639 <tparam1+0x4e9>
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    (%rax),%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x88(%rbp),%rax
mov    %ecx,(%rax)
jmp    1642 <tparam1+0x4f2>
mov    -0x58(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
jmp    1647 <tparam1+0x4f7>
jmp    164c <tparam1+0x4fc>
jmp    1651 <tparam1+0x501>
mov    -0x40(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x40(%rbp)
jmp    16f1 <tparam1+0x5a1>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%rax)
jmp    16f1 <tparam1+0x5a1>
jmp    16fb <tparam1+0x5ab>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
xor    $0x60,%ecx
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%ecx
xor    $0x60,%ecx
mov    %ecx,0x4(%rax)
jmp    16f1 <tparam1+0x5a1>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
xor    $0x7f,%ecx
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%ecx
xor    $0x7f,%ecx
mov    %ecx,0x4(%rax)
jmp    16f1 <tparam1+0x5a1>
mov    -0x58(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
imul   $0x6,%eax,%ecx
mov    -0x30(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
jmp    16f1 <tparam1+0x5a1>
mov    -0x58(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
shl    $0x1,%edx
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
jmp    1711 <tparam1+0x5c1>
jmp    16fb <tparam1+0x5ab>
mov    -0x34(%rbp),%eax
mov    %al,%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
jmp    11ae <tparam1+0x5e>
mov    -0x48(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x68(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x68(%rbp)
cmp    $0x0,%eax
jle    1743 <tparam1+0x5f3>
mov    -0x48(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1070 <strcat@plt>
jmp    171d <tparam1+0x5cd>
jmp    1748 <tparam1+0x5f8>
mov    -0x64(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x64(%rbp)
cmp    $0x0,%eax
jle    176e <tparam1+0x61e>
mov    -0x48(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1070 <strcat@plt>
jmp    1748 <tparam1+0x5f8>
mov    -0x10(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tparam1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,0x30(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rsi,%r15
movslq %edx,%rax
lea    (%rsi,%rax,1),%r13
add    $0x28,%eax
mov    %rax,0x40(%rsp)
movl   $0x0,0x10(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r9,(%rsp)
mov    %r9,0x38(%rsp)
movl   $0x0,0xc(%rsp)
movl   $0x0,0x14(%rsp)
jmp    11d0 <tparam1+0x80>
lea    0xf(%r12),%eax
test   %r12d,%r12d
cmovns %r12d,%eax
and    $0x7ffffff0,%eax
mov    %r12d,%ecx
sub    %eax,%ecx
add    %ecx,%ecx
sub    %ecx,%r12d
mov    (%rsp),%rax
mov    %r12d,(%rax)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdi,%r14
lea    0x5(%r15),%rax
cmp    %r13,%rax
jb     1250 <tparam1+0x100>
mov    0x10(%rsp),%esi
test   %esi,%esi
je     11ff <tparam1+0xaf>
movslq %esi,%rbx
add    %esi,%esi
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
mov    %esi,0x10(%rsp)
call   1060 <realloc@plt>
mov    %rbp,%rcx
jmp    123f <tparam1+0xef>
mov    0x40(%rsp),%rbp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %r15d,%edx
mov    %r15,0x20(%rsp)
mov    0x18(%rsp),%r15
sub    %r15d,%edx
mov    %rax,%rdi
mov    %r15,%rsi
call   1040 <memcpy@plt>
mov    $0x28,%ebx
mov    %r15,%rcx
mov    0x20(%rsp),%r15
mov    %ebp,%eax
mov    %ebp,0x10(%rsp)
mov    %r12,%rax
add    %rbx,%r13
mov    %rax,0x18(%rsp)
sub    %rcx,%rax
add    %rax,%r15
add    %rax,%r13
mov    (%r14),%al
cmp    $0x25,%al
je     1280 <tparam1+0x130>
test   %al,%al
je     152a <tparam1+0x3da>
add    $0x1,%r14
mov    %r14,%rdi
mov    %al,(%r15)
add    $0x1,%r15
jmp    11d0 <tparam1+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x2(%r14),%rdi
movsbl 0x1(%r14),%ecx
add    $0xffffffdb,%ecx
cmp    $0x4d,%ecx
ja     11d0 <tparam1+0x80>
mov    (%rsp),%rdx
mov    (%rdx),%r12d
lea    0xd5d(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
movsbl (%rdi),%eax
cmp    %eax,%r12d
jle    12c3 <tparam1+0x173>
movsbl 0x3(%r14),%eax
add    %eax,%r12d
mov    (%rsp),%rax
mov    %r12d,(%rax)
add    $0x4,%r14
mov    %r14,%rdi
jmp    11d0 <tparam1+0x80>
movslq %r12d,%rax
imul   $0x66666667,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rax
add    %ecx,%eax
lea    (%rax,%rax,2),%eax
lea    (%r12,%rax,2),%eax
mov    (%rsp),%rcx
mov    %eax,(%rcx)
jmp    11d0 <tparam1+0x80>
addq   $0xfffffffffffffffc,(%rsp)
jmp    11d0 <tparam1+0x80>
cmp    $0xa,%r12d
jl     1398 <tparam1+0x248>
cmp    $0x64,%r12d
jb     135c <tparam1+0x20c>
cmp    $0x3e8,%r12d
jl     133c <tparam1+0x1ec>
mov    %r12d,%eax
imul   $0x10624dd3,%rax,%rax
shr    $0x26,%rax
lea    0x30(%rax),%ecx
mov    %cl,(%r15)
add    $0x1,%r15
imul   $0x3e8,%eax,%eax
sub    %eax,%r12d
movslq %r12d,%rax
imul   $0x51eb851f,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x25,%rax
add    %ecx,%eax
add    $0x30,%al
mov    %al,(%r15)
add    $0x1,%r15
movslq %r12d,%r12
imul   $0x51eb851f,%r12,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x25,%rax
add    %ecx,%eax
imul   $0x64,%eax,%eax
sub    %eax,%r12d
movsbl %r12b,%eax
imul   $0x67,%eax,%eax
movzwl %ax,%eax
movswl %ax,%ecx
shr    $0xf,%eax
shr    $0xa,%ecx
add    %al,%cl
add    $0x30,%cl
mov    %cl,(%r15)
add    $0x1,%r15
movslq %r12d,%rax
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,(%r15)
add    $0x1,%r15
addq   $0x4,(%rsp)
jmp    11d0 <tparam1+0x80>
add    $0x1,%r12d
mov    (%rsp),%rax
mov    %r12d,(%rax)
addl   $0x1,0x4(%rax)
jmp    11d0 <tparam1+0x80>
xor    $0x7f,%r12d
mov    (%rsp),%rax
mov    %r12d,(%rax)
xorb   $0x7f,0x4(%rax)
jmp    11d0 <tparam1+0x80>
xor    $0x60,%r12d
mov    (%rsp),%rax
mov    %r12d,(%rax)
xorb   $0x60,0x4(%rax)
jmp    11d0 <tparam1+0x80>
mov    (%rsp),%rcx
mov    0x4(%rcx),%eax
mov    %eax,(%rcx)
mov    %r12d,0x4(%rcx)
addq   $0x4,0x38(%rsp)
jmp    11d0 <tparam1+0x80>
cmp    $0x60,%r12d
jl     1443 <tparam1+0x2f3>
mov    %r12d,%eax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x26,%rax
mov    %al,(%r15)
add    $0x1,%r15
shl    $0x5,%eax
lea    (%rax,%rax,2),%eax
sub    %eax,%r12d
movsbl 0x2(%r14),%eax
add    $0x3,%r14
add    %r12d,%eax
mov    %r14,%rdi
mov    %eax,%r12d
mov    0x30(%rsp),%rbx
test   %rbx,%rbx
je     14b3 <tparam1+0x363>
mov    %rdi,0x20(%rsp)
mov    0xc(%rsp),%ebp
mov    0x28(%rsp),%r14
jmp    1484 <tparam1+0x334>
nop
add    $0x1,%ebp
mov    %rbx,%rdi
call   1030 <strlen@plt>
cltq
sub    %rax,%r13
add    $0x1,%r12d
cmp    $0xa,%r12d
ja     14aa <tparam1+0x35a>
mov    $0x601,%eax
bt     %r12d,%eax
jae    14aa <tparam1+0x35a>
mov    0x38(%rsp),%rax
cmp    %rax,(%rsp)
jne    1470 <tparam1+0x320>
addl   $0x1,0x14(%rsp)
mov    %r14,%rdi
jmp    1476 <tparam1+0x326>
mov    %ebp,0xc(%rsp)
mov    0x20(%rsp),%rdi
or     $0x80,%r12b
mov    %r12b,(%r15)
add    $0x1,%r15
addq   $0x4,(%rsp)
jmp    11d0 <tparam1+0x80>
movzbl 0x4(%r14),%ecx
and    $0x7f,%ecx
cmpb   $0x70,0x3(%r14)
jne    14e2 <tparam1+0x392>
mov    (%rsp),%rax
mov    -0x100(%rax,%rcx,4),%ecx
mov    (%rdi),%al
add    $0xd6,%al
cmp    $0x5,%al
ja     1518 <tparam1+0x3c8>
movzbl %al,%eax
lea    0xc44(%rip),%rdx
movslq (%rdx,%rax,4),%rax
add    %rdx,%rax
jmp    *%rax
imul   %r12d,%ecx
jmp    1518 <tparam1+0x3c8>
add    %r12d,%ecx
jmp    1518 <tparam1+0x3c8>
sub    %ecx,%r12d
mov    %r12d,%ecx
jmp    1518 <tparam1+0x3c8>
mov    %r12d,%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    (%rsp),%rax
mov    %ecx,(%rax)
add    $0x5,%r14
mov    %r14,%rdi
jmp    11d0 <tparam1+0x80>
movb   $0x0,(%r15)
mov    0x14(%rsp),%ebp
test   %ebp,%ebp
mov    0x28(%rsp),%rbx
jle    1553 <tparam1+0x403>
add    $0x1,%ebp
xchg   %ax,%ax
mov    %r15,%rdi
mov    %rbx,%rsi
call   1070 <strcat@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1540 <tparam1+0x3f0>
mov    0xc(%rsp),%ebp
test   %ebp,%ebp
mov    0x30(%rsp),%rbx
jle    1583 <tparam1+0x433>
add    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15,%rdi
mov    %rbx,%rsi
call   1070 <strcat@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1570 <tparam1+0x420>
mov    0x18(%rsp),%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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