#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*/ time_t;
struct tm {
  char tm_year;
  char tm_mon;
  char tm_mday;
};
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ fwrite(char *, int, int, int /*<<< orphan*/ *);
struct tm *localtime(int /*<<< orphan*/ *);
int /*<<< orphan*/ printf(char *);
int rand();
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ *stdout;
int strlen(char *);
int /*<<< orphan*/ strncpy(char *, char *, int);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main(int argc, char *argv[]) {
  char keyString[256];
  char nameString[128];
  struct tm *tms;
  time_t tm;
  int i, vlen;
  unsigned long sum;
  FILE *kf;
  char wbuffer[256];
  char *schar;
  char Version[] = "2.0";
  char xAlphaMask[256] = {
      0x87, 0xF6, 0xA1, 0x7C, 0xD6, 0x3A, 0x87, 0xE6, 0x0E, 0x84, 0xF6, 0xCA,
      0x81, 0xBF, 0x76, 0x12, 0xE8, 0x3D, 0xF7, 0x6A, 0x29, 0xC3, 0x84, 0xB5,
      0x6B, 0xC3, 0x4A, 0x8F, 0x76, 0xD9, 0x8A, 0x76, 0xA2, 0x3B, 0x98, 0xD7,
      0xE6, 0xF5, 0x9C, 0x87, 0x6C, 0x49, 0x8C, 0x7D, 0x65, 0xD2, 0xAF, 0x17,
      0x8A, 0xD6, 0x49, 0xF8, 0x7A, 0x1B, 0x23, 0x9C, 0x7C, 0xC8, 0xA6, 0x19,
      0xEE, 0x28, 0x7F, 0x68, 0x48, 0x7D, 0xD6, 0x5A, 0xB3, 0x8C, 0xF7, 0x52,
      0xFE, 0x32, 0xD9, 0x84, 0xA7, 0xA5, 0xC9, 0x87, 0x2A, 0x8F, 0xF7, 0x6D,
      0x48, 0x7D, 0xE6, 0x25, 0xED, 0x54, 0x9B, 0xC3, 0x6A, 0xA5, 0x98, 0x64,
      0xAC, 0x10, 0xD9, 0x8F, 0xE7, 0x30, 0xA9, 0x54, 0xE4, 0x5C, 0xD4, 0x35,
      0xA4, 0x35, 0xFF, 0x26, 0x4F, 0x87, 0xEA, 0x65, 0x3B, 0xDE, 0x48, 0x76,
      0x1E, 0xB8, 0x72, 0xC5, 0xD8, 0x5E, 0x8A, 0x24};
  char filler[] = "Well done, you have cracked the keyfile code!  Please don't "
                  "pass it on, I need to eat too - Sander";
  if (argc != 2) {
    printf("Generate Keyfile for Becasso 1.5 registration\n");
    printf("Usage: gen_key <name>\n");
    printf("(Quote <name>; it will probably contain spaces)\n");
    return 2;
  }
  strncpy(nameString, argv[1], 127);
  for (i = 0; i <= strlen(nameString); i++)
    keyString[2 * i] = nameString[i];
  for (i = strlen(nameString) + 1; i < 128; i++)
    keyString[2 * i] = rand() & 0xFF;
  tm = time(NULL);
  tms = localtime(&tm);
  vlen = strlen(Version);
  keyString[1] = vlen;
  keyString[3] = tms->tm_year;
  keyString[5] = tms->tm_mon;
  keyString[7] = tms->tm_mday;
  keyString[9] = 31;
  keyString[11] = 42;
  keyString[13] = 2;
  for (i = 0; i <= vlen; i++)
    keyString[2 * i + 15] = Version[i];
  for (i = 0; i < strlen(filler); i++)
    keyString[2 * i + 2 * vlen + 15] = filler[i];
  sum = 0;
  for (i = 0; i < 252; i++)
    sum += keyString[i];
  schar = (char *)(&sum);
  keyString[252] = schar[0];
  keyString[253] = schar[1];
  keyString[254] = schar[2];
  keyString[255] = schar[3];
  for (i = 0; i < 255; i++)
    wbuffer[i] = keyString[i] ^ xAlphaMask[i];
  kf = stdout;
  if (kf)
    fwrite(wbuffer, 1, 255, kf);
  else {
    fprintf(stderr, "Couldn't open %s for writing\n", "Keyfile");
    return 1;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x450,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    0xe51(%rip),%eax
mov    %eax,-0x2cc(%rbp)
lea    -0x3d0(%rbp),%rdi
lea    0xeed(%rip),%rsi
mov    $0x100,%edx
call   1080 <memcpy@plt>
lea    -0x440(%rbp),%rdi
lea    0xfd5(%rip),%rsi
mov    $0x63,%edx
call   1080 <memcpy@plt>
cmpl   $0x2,-0x8(%rbp)
je     121f <main+0x8f>
lea    0xe0e(%rip),%rdi
call   1060 <printf@plt>
lea    0xe31(%rip),%rdi
call   1060 <printf@plt>
lea    0xe3c(%rip),%rdi
call   1060 <printf@plt>
movl   $0x2,-0x4(%rbp)
jmp    15a8 <main+0x418>
lea    -0x190(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
mov    $0x7f,%edx
call   1040 <strncpy@plt>
movl   $0x0,-0x1a0(%rbp)
mov    -0x1a0(%rbp),%eax
mov    %eax,-0x444(%rbp)
lea    -0x190(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x444(%rbp),%eax
cmp    %ecx,%eax
jg     129e <main+0x10e>
movslq -0x1a0(%rbp),%rax
mov    -0x190(%rbp,%rax,1),%cl
mov    -0x1a0(%rbp),%eax
shl    $0x1,%eax
cltq
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x1a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
jmp    1242 <main+0xb2>
lea    -0x190(%rbp),%rdi
call   1050 <strlen@plt>
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
cmpl   $0x80,-0x1a0(%rbp)
jge    12f7 <main+0x167>
mov    $0x0,%al
call   10b0 <rand@plt>
and    $0xff,%eax
mov    %al,%cl
mov    -0x1a0(%rbp),%eax
shl    $0x1,%eax
cltq
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x1a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
jmp    12b3 <main+0x123>
xor    %eax,%eax
mov    %eax,%edi
call   1090 <time@plt>
mov    %eax,-0x19c(%rbp)
lea    -0x19c(%rbp),%rdi
call   1030 <localtime@plt>
mov    %rax,-0x198(%rbp)
lea    -0x2cc(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
mov    %al,-0x10f(%rbp)
mov    -0x198(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x10d(%rbp)
mov    -0x198(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x10b(%rbp)
mov    -0x198(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x109(%rbp)
movb   $0x1f,-0x107(%rbp)
movb   $0x2a,-0x105(%rbp)
movb   $0x2,-0x103(%rbp)
movl   $0x0,-0x1a0(%rbp)
mov    -0x1a0(%rbp),%eax
cmp    -0x1a4(%rbp),%eax
jg     13ce <main+0x23e>
movslq -0x1a0(%rbp),%rax
mov    -0x2cc(%rbp,%rax,1),%cl
mov    -0x1a0(%rbp),%eax
shl    $0x1,%eax
add    $0xf,%eax
cltq
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x1a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
jmp    1385 <main+0x1f5>
movl   $0x0,-0x1a0(%rbp)
mov    -0x1a0(%rbp),%eax
mov    %eax,-0x448(%rbp)
lea    -0x440(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x448(%rbp),%eax
cmp    %ecx,%eax
jge    1442 <main+0x2b2>
movslq -0x1a0(%rbp),%rax
mov    -0x440(%rbp,%rax,1),%cl
mov    -0x1a0(%rbp),%eax
shl    $0x1,%eax
mov    -0x1a4(%rbp),%edx
shl    $0x1,%edx
add    %edx,%eax
add    $0xf,%eax
cltq
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x1a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
jmp    13d8 <main+0x248>
movq   $0x0,-0x1b0(%rbp)
movl   $0x0,-0x1a0(%rbp)
cmpl   $0xfc,-0x1a0(%rbp)
jge    1499 <main+0x309>
movslq -0x1a0(%rbp),%rax
movsbq -0x110(%rbp,%rax,1),%rax
ff ff
add    -0x1b0(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x1a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
jmp    1457 <main+0x2c7>
lea    -0x1b0(%rbp),%rax
mov    %rax,-0x2c8(%rbp)
mov    -0x2c8(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x14(%rbp)
mov    -0x2c8(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x13(%rbp)
mov    -0x2c8(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x12(%rbp)
mov    -0x2c8(%rbp),%rax
mov    0x3(%rax),%al
mov    %al,-0x11(%rbp)
movl   $0x0,-0x1a0(%rbp)
cmpl   $0xff,-0x1a0(%rbp)
jge    1538 <main+0x3a8>
movslq -0x1a0(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
movslq -0x1a0(%rbp),%rcx
movsbl -0x3d0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
movslq -0x1a0(%rbp),%rax
mov    %cl,-0x2c0(%rbp,%rax,1)
mov    -0x1a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
jmp    14e4 <main+0x354>
mov    0x2a99(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x1b8(%rbp)
cmpq   $0x0,-0x1b8(%rbp)
je     1579 <main+0x3e9>
lea    -0x2c0(%rbp),%rdi
mov    -0x1b8(%rbp),%rcx
mov    $0x1,%esi
mov    $0xff,%edx
call   10a0 <fwrite@plt>
jmp    15a1 <main+0x411>
mov    0x2a60(%rip),%rax
mov    (%rax),%edi
lea    0xaf2(%rip),%rsi
lea    0xb09(%rip),%rdx
call   1070 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    15a8 <main+0x418>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x450,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x308,%rsp
movl   $0x302e32,0x8(%rsp)
movaps 0xf34(%rip),%xmm0
movaps %xmm0,0x160(%rsp)
movaps 0xf15(%rip),%xmm0
movaps %xmm0,0x150(%rsp)
movaps 0xef6(%rip),%xmm0
movaps %xmm0,0x140(%rsp)
movaps 0xed7(%rip),%xmm0
movaps %xmm0,0x130(%rsp)
movaps 0xeb8(%rip),%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0xe99(%rip),%xmm0
movaps %xmm0,0x110(%rsp)
movl   $0x726564,0x16f(%rsp)
cmp    $0x2,%edi
jne    1301 <main+0x181>
mov    0x8(%rsi),%rsi
lea    0x280(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x7f,%edx
call   1040 <strncpy@plt>
mov    %rbx,%rdi
call   1060 <strlen@plt>
test   %eax,%eax
js     125f <main+0xdf>
mov    $0xffffffffffffffff,%rbp
lea    0x280(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movzbl 0x281(%rsp,%rbp,1),%eax
mov    %al,0x12(%rsp,%rbp,2)
mov    %rbx,%rdi
call   1060 <strlen@plt>
cltq
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1240 <main+0xc0>
lea    0x280(%rsp),%rdi
call   1060 <strlen@plt>
cmp    $0x7e,%eax
jg     1295 <main+0x115>
mov    %eax,%ebp
add    $0xffffff81,%ebp
lea    (%rax,%rax,1),%ebx
add    $0x2,%ebx
nopl   0x0(%rax)
xor    %eax,%eax
call   10a0 <rand@plt>
movslq %ebx,%rbx
mov    %al,0x10(%rsp,%rbx,1)
add    $0x2,%ebx
inc    %ebp
jne    1280 <main+0x100>
xor    %edi,%edi
call   1080 <time@plt>
mov    %eax,0xc(%rsp)
lea    0xc(%rsp),%rdi
call   1030 <localtime@plt>
mov    %rax,%rbx
lea    0x8(%rsp),%rdi
call   1060 <strlen@plt>
mov    %eax,%r14d
mov    %r14b,0x11(%rsp)
mov    (%rbx),%al
mov    %al,0x13(%rsp)
mov    0x1(%rbx),%al
mov    %al,0x15(%rsp)
mov    0x2(%rbx),%al
mov    %al,0x17(%rsp)
movb   $0x1f,0x19(%rsp)
movb   $0x2a,0x1b(%rsp)
movb   $0x2,0x1d(%rsp)
test   %r14d,%r14d
js     13a0 <main+0x220>
mov    %r14d,%ecx
add    $0x1,%rcx
mov    %ecx,%edi
and    $0x3,%edi
cmp    $0x3,%r14d
jae    132f <main+0x1af>
xor    %edx,%edx
jmp    136d <main+0x1ed>
lea    0xe01(%rip),%rdi
call   1050 <puts@plt>
lea    0xe23(%rip),%rdi
call   1050 <puts@plt>
lea    0xe2d(%rip),%rdi
call   1050 <puts@plt>
mov    $0x2,%eax
jmp    1600 <main+0x480>
and    $0xfffffffc,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x8(%rsp,%rdx,1),%ebx
movzbl 0x9(%rsp,%rdx,1),%eax
mov    %bl,0x1f(%rsp,%rdx,2)
mov    %al,0x21(%rsp,%rdx,2)
movzbl 0xa(%rsp,%rdx,1),%eax
mov    %al,0x23(%rsp,%rdx,2)
movzbl 0xb(%rsp,%rdx,1),%eax
mov    %al,0x25(%rsp,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1340 <main+0x1c0>
test   %rdi,%rdi
je     13a0 <main+0x220>
lea    (%rsp,%rdx,2),%rcx
add    $0x1f,%rcx
add    %rsp,%rdx
add    $0x8,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdx,%rsi,1),%ebx
mov    %bl,(%rcx,%rsi,2)
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1390 <main+0x210>
lea    0x110(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
jle    13f6 <main+0x276>
lea    (%r14,%r14,1),%ebx
add    $0xf,%ebx
xor    %r15d,%r15d
lea    0x110(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x110(%rsp,%r15,1),%eax
movslq %ebx,%rbx
mov    %al,0x10(%rsp,%rbx,1)
add    $0x1,%r15
mov    %r14,%rdi
call   1060 <strlen@plt>
cltq
add    $0x2,%ebx
cmp    %rax,%r15
jl     13d0 <main+0x250>
xor    %ecx,%ecx
xor    %eax,%eax
xor    %edx,%edx
xor    %edi,%edi
xor    %esi,%esi
movsbq 0x10(%rsp,%rcx,1),%rbp
shl    $0x18,%esi
movzbl %dil,%edi
shl    $0x10,%rdi
or     %rsi,%rdi
shl    $0x8,%edx
movzwl %dx,%edx
or     %rdi,%rdx
movzbl %al,%eax
or     %rdx,%rax
add    %rbp,%rax
mov    %rax,%rdx
shr    $0x8,%rdx
mov    %rax,%rdi
shr    $0x10,%rdi
mov    %rax,%rsi
shr    $0x18,%rsi
add    $0x1,%rcx
cmp    $0xfc,%rcx
jne    1400 <main+0x280>
mov    %al,0x10c(%rsp)
mov    %dl,0x10d(%rsp)
mov    %dil,0x10e(%rsp)
mov    %sil,0x10f(%rsp)
movaps 0x10(%rsp),%xmm0
movaps 0x20(%rsp),%xmm1
movaps 0x30(%rsp),%xmm2
xorps  0xb84(%rip),%xmm0
movaps 0x40(%rsp),%xmm3
xorps  0xb88(%rip),%xmm1
movaps %xmm0,0x180(%rsp)
xorps  0xb89(%rip),%xmm2
xorps  0xb92(%rip),%xmm3
movaps %xmm1,0x190(%rsp)
movaps %xmm2,0x1a0(%rsp)
movaps 0x50(%rsp),%xmm0
movaps 0x60(%rsp),%xmm1
xorps  0xb81(%rip),%xmm0
xorps  0xb8a(%rip),%xmm1
movaps %xmm3,0x1b0(%rsp)
movaps %xmm0,0x1c0(%rsp)
movaps 0x70(%rsp),%xmm0
movaps 0x80(%rsp),%xmm2
xorps  0xb76(%rip),%xmm0
xorps  0xb7f(%rip),%xmm2
movaps %xmm1,0x1d0(%rsp)
movaps %xmm0,0x1e0(%rsp)
movaps %xmm2,0x1f0(%rsp)
movaps 0x90(%rsp),%xmm0
movaps 0xa0(%rsp),%xmm1
movaps 0xb0(%rsp),%xmm2
movaps 0xc0(%rsp),%xmm3
movaps %xmm0,0x200(%rsp)
movaps %xmm1,0x210(%rsp)
movaps %xmm2,0x220(%rsp)
movaps %xmm3,0x230(%rsp)
movaps 0xd0(%rsp),%xmm0
movaps 0xe0(%rsp),%xmm1
movaps %xmm0,0x240(%rsp)
movaps %xmm1,0x250(%rsp)
movaps 0xf0(%rsp),%xmm0
movaps %xmm0,0x260(%rsp)
mov    0x100(%rsp),%rax
mov    %rax,0x270(%rsp)
mov    0x108(%rsp),%al
mov    %al,0x278(%rsp)
movzwl 0x109(%rsp),%eax
mov    %ax,0x279(%rsp)
mov    0x10b(%rsp),%eax
mov    %eax,0x27b(%rsp)
mov    0x2a1c(%rip),%rax
mov    (%rax),%rcx
test   %rcx,%rcx
je     15df <main+0x45f>
lea    0x180(%rsp),%rdi
mov    $0x1,%esi
mov    $0xff,%edx
call   1090 <fwrite@plt>
xor    %eax,%eax
jmp    1600 <main+0x480>
mov    0x29fa(%rip),%rax
mov    (%rax),%edi
lea    0xaf4(%rip),%rsi
lea    0xb0b(%rip),%rdx
call   1070 <fprintf@plt>
mov    $0x1,%eax
add    $0x308,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.tm = type { i8, i8, i8 }
@__const.main.Version = [4 x i8] c"2.0\00"
@__const.main.xAlphaMask = <{ [128 x i8], [128 x i8] }> <{ [128 x i8] c"\87\F6\A1|\D6:\87\E6\0E\84\F6\CA\81\BFv\12\E8=\F7j)\C3\84\B5k\C3J\8Fv\D9\8Av\A2;\98\D7\E6\F5\9C\87lI\8C}e\D2\AF\17\8A\D6I\F8z\1B#\9C|\C8\A6\19\EE(\7FhH}\D6Z\B3\8C\F7R\FE2\D9\84\A7\A5\C9\87*\8F\F7mH}\E6%\EDT\9B\C3j\A5\98d\AC\10\D9\8F\E70\A9T\E4\\\D45\A45\FF&O\87\EAe;\DEHv\1E\B8r\C5\D8^\8A$", [128 x i8] zeroinitializer }>
@__const.main.filler = [99 x i8] c"Well done, you have cracked the keyfile code! Please don't pass it on, I need to eat too - Sander\00"
@.str = [47 x i8] c"Generate Keyfile for Becasso 1.5 registration\0A\00"
@.str.1 = [23 x i8] c"Usage: gen_key <name>\0A\00"
@.str.2 = [49 x i8] c"(Quote <name>; it will probably contain spaces)\0A\00"
@stdout = global i32* null
@stderr = global i32 0
@.str.3 = [30 x i8] c"Couldn't open %s for writing\0A\00"
@.str.4 = [8 x i8] c"Keyfile\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [256 x i8]
%7 = alloca [128 x i8]
%8 = alloca %struct.tm*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i64
%13 = alloca i32*
%14 = alloca [256 x i8]
%15 = alloca i8*
%16 = alloca [4 x i8]
%17 = alloca [256 x i8]
%18 = alloca [99 x i8]
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%19 = bitcast [4 x i8]* %16 to i8*
%20 = bitcast [256 x i8]* %17 to i8*
%21 = bitcast [99 x i8]* %18 to i8*
%22 = load i32, i32* %4
%23 = icmp ne i32 %22, 2
br i1 %23, label %24, label %28
24: ; preds = %2
%25 = call i32 @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str, i64 0, i64 0))
%26 = call i32 @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0))
%27 = call i32 @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.2, i64 0, i64 0))
store i32 2, i32* %3
br label %198
28: ; preds = %2
%29 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
%30 = load i8**, i8*** %5
%31 = getelementptr inbounds i8*, i8** %30, i64 1
%32 = load i8*, i8** %31
%33 = call i32 @strncpy(i8* %29, i8* %32, i32 127)
store i32 0, i32* %10
br label %34
34: ; preds = %48, %28
%35 = load i32, i32* %10
%36 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
%37 = call i32 @strlen(i8* %36)
%38 = icmp sle i32 %35, %37
br i1 %38, label %39, label %51
39: ; preds = %34
%40 = load i32, i32* %10
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 %41
%43 = load i8, i8* %42
%44 = load i32, i32* %10
%45 = mul nsw i32 2, %44
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %46
store i8 %43, i8* %47
br label %48
48: ; preds = %39
%49 = load i32, i32* %10
%50 = add nsw i32 %49, 1
store i32 %50, i32* %10
br label %34
51: ; preds = %34
%52 = getelementptr inbounds [128 x i8], [128 x i8]* %7, i64 0, i64 0
%53 = call i32 @strlen(i8* %52)
%54 = add nsw i32 %53, 1
store i32 %54, i32* %10
br label %55
55: ; preds = %66, %51
%56 = load i32, i32* %10
%57 = icmp slt i32 %56, 128
br i1 %57, label %58, label %69
58: ; preds = %55
%59 = call i32 (...) @rand()
%60 = and i32 %59, 255
%61 = trunc i32 %60 to i8
%62 = load i32, i32* %10
%63 = mul nsw i32 2, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %64
store i8 %61, i8* %65
br label %66
66: ; preds = %58
%67 = load i32, i32* %10
%68 = add nsw i32 %67, 1
store i32 %68, i32* %10
br label %55
69: ; preds = %55
%70 = call i32 @time(i32* null)
store i32 %70, i32* %9
%71 = call %struct.tm* @localtime(i32* %9)
store %struct.tm* %71, %struct.tm** %8
%72 = getelementptr inbounds [4 x i8], [4 x i8]* %16, i64 0, i64 0
%73 = call i32 @strlen(i8* %72)
store i32 %73, i32* %11
%74 = load i32, i32* %11
%75 = trunc i32 %74 to i8
%76 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 1
store i8 %75, i8* %76
%77 = load %struct.tm*, %struct.tm** %8
%78 = getelementptr inbounds %struct.tm, %struct.tm* %77, i32 0, i32 0
%79 = load i8, i8* %78
%80 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 3
store i8 %79, i8* %80
%81 = load %struct.tm*, %struct.tm** %8
%82 = getelementptr inbounds %struct.tm, %struct.tm* %81, i32 0, i32 1
%83 = load i8, i8* %82
%84 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 5
store i8 %83, i8* %84
%85 = load %struct.tm*, %struct.tm** %8
%86 = getelementptr inbounds %struct.tm, %struct.tm* %85, i32 0, i32 2
%87 = load i8, i8* %86
%88 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 7
store i8 %87, i8* %88
%89 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 9
store i8 31, i8* %89
%90 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 11
store i8 42, i8* %90
%91 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 13
store i8 2, i8* %91
store i32 0, i32* %10
br label %92
92: ; preds = %106, %69
%93 = load i32, i32* %10
%94 = load i32, i32* %11
%95 = icmp sle i32 %93, %94
br i1 %95, label %96, label %109
96: ; preds = %92
%97 = load i32, i32* %10
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [4 x i8], [4 x i8]* %16, i64 0, i64 %98
%100 = load i8, i8* %99
%101 = load i32, i32* %10
%102 = mul nsw i32 2, %101
%103 = add nsw i32 %102, 15
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %104
store i8 %100, i8* %105
br label %106
106: ; preds = %96
%107 = load i32, i32* %10
%108 = add nsw i32 %107, 1
store i32 %108, i32* %10
br label %92
109: ; preds = %92
store i32 0, i32* %10
br label %110
110: ; preds = %128, %109
%111 = load i32, i32* %10
%112 = getelementptr inbounds [99 x i8], [99 x i8]* %18, i64 0, i64 0
%113 = call i32 @strlen(i8* %112)
%114 = icmp slt i32 %111, %113
br i1 %114, label %115, label %131
115: ; preds = %110
%116 = load i32, i32* %10
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [99 x i8], [99 x i8]* %18, i64 0, i64 %117
%119 = load i8, i8* %118
%120 = load i32, i32* %10
%121 = mul nsw i32 2, %120
%122 = load i32, i32* %11
%123 = mul nsw i32 2, %122
%124 = add nsw i32 %121, %123
%125 = add nsw i32 %124, 15
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %126
store i8 %119, i8* %127
br label %128
128: ; preds = %115
%129 = load i32, i32* %10
%130 = add nsw i32 %129, 1
store i32 %130, i32* %10
br label %110
131: ; preds = %110
store i64 0, i64* %12
store i32 0, i32* %10
br label %132
132: ; preds = %143, %131
%133 = load i32, i32* %10
%134 = icmp slt i32 %133, 252
br i1 %134, label %135, label %146
135: ; preds = %132
%136 = load i32, i32* %10
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %137
%139 = load i8, i8* %138
%140 = sext i8 %139 to i64
%141 = load i64, i64* %12
%142 = add i64 %141, %140
store i64 %142, i64* %12
br label %143
143: ; preds = %135
%144 = load i32, i32* %10
%145 = add nsw i32 %144, 1
store i32 %145, i32* %10
br label %132
146: ; preds = %132
%147 = bitcast i64* %12 to i8*
store i8* %147, i8** %15
%148 = load i8*, i8** %15
%149 = getelementptr inbounds i8, i8* %148, i64 0
%150 = load i8, i8* %149
%151 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 252
store i8 %150, i8* %151
%152 = load i8*, i8** %15
%153 = getelementptr inbounds i8, i8* %152, i64 1
%154 = load i8, i8* %153
%155 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 253
store i8 %154, i8* %155
%156 = load i8*, i8** %15
%157 = getelementptr inbounds i8, i8* %156, i64 2
%158 = load i8, i8* %157
%159 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 254
store i8 %158, i8* %159
%160 = load i8*, i8** %15
%161 = getelementptr inbounds i8, i8* %160, i64 3
%162 = load i8, i8* %161
%163 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 255
store i8 %162, i8* %163
store i32 0, i32* %10
br label %164
164: ; preds = %183, %146
%165 = load i32, i32* %10
%166 = icmp slt i32 %165, 255
br i1 %166, label %167, label %186
167: ; preds = %164
%168 = load i32, i32* %10
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %169
%171 = load i8, i8* %170
%172 = sext i8 %171 to i32
%173 = load i32, i32* %10
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 %174
%176 = load i8, i8* %175
%177 = sext i8 %176 to i32
%178 = xor i32 %172, %177
%179 = trunc i32 %178 to i8
%180 = load i32, i32* %10
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %181
store i8 %179, i8* %182
br label %183
183: ; preds = %167
%184 = load i32, i32* %10
%185 = add nsw i32 %184, 1
store i32 %185, i32* %10
br label %164
186: ; preds = %164
%187 = load i32*, i32** @stdout
store i32* %187, i32** %13
%188 = load i32*, i32** %13
%189 = icmp ne i32* %188, null
br i1 %189, label %190, label %194
190: ; preds = %186
%191 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 0
%192 = load i32*, i32** %13
%193 = call i32 @fwrite(i8* %191, i32 1, i32 255, i32* %192)
br label %197
194: ; preds = %186
%195 = load i32, i32* @stderr
%196 = call i32 @fprintf(i32 %195, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
store i32 1, i32* %3
br label %198
197: ; preds = %190
store i32 0, i32* %3
br label %198
198: ; preds = %197, %194, %24
%199 = load i32, i32* %3
ret i32 %199
}

LLVM IR (-O2):
%struct.tm = type { i8, i8, i8 }
@__const.main.filler = [99 x i8] c"Well done, you have cracked the keyfile code! Please don't pass it on, I need to eat too - Sander\00"
@stdout = global i32* null
@stderr = global i32 0
@.str.3 = [30 x i8] c"Couldn't open %s for writing\0A\00"
@.str.4 = [8 x i8] c"Keyfile\00"
@str = [46 x i8] c"Generate Keyfile for Becasso 1.5 registration\00"
@str.5 = [22 x i8] c"Usage: gen_key <name>\00"
@str.6 = [48 x i8] c"(Quote <name>; it will probably contain spaces)\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [256 x i8]
%4 = alloca [128 x i8]
%5 = alloca i32
%6 = alloca [256 x i8]
%7 = alloca i32
%8 = bitcast i32* %7 to [4 x i8]*
%9 = alloca [99 x i8]
%10 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%11 = getelementptr inbounds [128 x i8], [128 x i8]* %4, i64 0, i64 0
%12 = bitcast i32* %5 to i8*
%13 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%14 = bitcast i32* %7 to i8*
store i32 3157554, i32* %7
%15 = getelementptr inbounds [99 x i8], [99 x i8]* %9, i64 0, i64 0
%16 = icmp eq i32 %0, 2
br i1 %16, label %21, label %17
17: ; preds = %2
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.5, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.6, i64 0, i64 0))
br label %293
21: ; preds = %2
%22 = getelementptr inbounds i8*, i8** %1, i64 1
%23 = load i8*, i8** %22
%24 = call i32 @strncpy(i8* %11, i8* %23, i32 127)
%25 = call i32 @strlen(i8* %11)
%26 = icmp slt i32 %25, 0
br i1 %26, label %37, label %27
27: ; preds = %21, %27
%28 = phi i64 [ %33, %27 ], [ 0, %21 ]
%29 = getelementptr inbounds [128 x i8], [128 x i8]* %4, i64 0, i64 %28
%30 = load i8, i8* %29
%31 = shl nuw nsw i64 %28, 1
%32 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %31
store i8 %30, i8* %32
%33 = add nuw nsw i64 %28, 1
%34 = call i32 @strlen(i8* %11)
%35 = sext i32 %34 to i64
%36 = icmp slt i64 %28, %35
br i1 %36, label %27, label %37
37: ; preds = %27, %21
%38 = call i32 @strlen(i8* %11)
%39 = icmp slt i32 %38, 127
br i1 %39, label %40, label %52
40: ; preds = %37
%41 = zext i32 %38 to i64
br label %42
42: ; preds = %40, %42
%43 = phi i64 [ %41, %40 ], [ %44, %42 ]
%44 = add i64 %43, 1
%45 = call i32 (...) @rand()
%46 = trunc i32 %45 to i8
%47 = trunc i64 %44 to i32
%48 = shl nsw i32 %47, 1
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %49
store i8 %46, i8* %50
%51 = icmp eq i32 %47, 127
br i1 %51, label %52, label %42
52: ; preds = %42, %37
%53 = call i32 @time(i32* null)
store i32 %53, i32* %5
%54 = call %struct.tm* @localtime(i32* %5)
%55 = call i32 @strlen(i8* %14)
%56 = trunc i32 %55 to i8
%57 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 1
store i8 %56, i8* %57
%58 = getelementptr inbounds %struct.tm, %struct.tm* %54, i64 0, i32 0
%59 = load i8, i8* %58
%60 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 3
store i8 %59, i8* %60
%61 = getelementptr inbounds %struct.tm, %struct.tm* %54, i64 0, i32 1
%62 = load i8, i8* %61
%63 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 5
store i8 %62, i8* %63
%64 = getelementptr inbounds %struct.tm, %struct.tm* %54, i64 0, i32 2
%65 = load i8, i8* %64
%66 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 7
store i8 %65, i8* %66
%67 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 9
store i8 31, i8* %67
%68 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 11
store i8 42, i8* %68
%69 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 13
store i8 2, i8* %69
%70 = icmp slt i32 %55, 0
br i1 %70, label %93, label %71
71: ; preds = %52
%72 = add nuw i32 %55, 1
%73 = zext i32 %72 to i64
%74 = add nsw i64 %73, -1
%75 = and i64 %73, 3
%76 = icmp ult i64 %74, 3
br i1 %76, label %79, label %77
77: ; preds = %71
%78 = and i64 %73, 4294967292
br label %96
79: ; preds = %96, %71
%80 = phi i64 [ 0, %71 ], [ %122, %96 ]
%81 = icmp eq i64 %75, 0
br i1 %81, label %93, label %82
82: ; preds = %79, %82
%83 = phi i64 [ %90, %82 ], [ %80, %79 ]
%84 = phi i64 [ %91, %82 ], [ 0, %79 ]
%85 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %83
%86 = load i8, i8* %85
%87 = shl nuw nsw i64 %83, 1
%88 = add nuw nsw i64 %87, 15
%89 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %88
store i8 %86, i8* %89
%90 = add nuw nsw i64 %83, 1
%91 = add i64 %84, 1
%92 = icmp eq i64 %91, %75
br i1 %92, label %93, label %82
93: ; preds = %79, %82, %52
%94 = call i32 @strlen(i8* %15)
%95 = icmp sgt i32 %94, 0
br i1 %95, label %125, label %139
96: ; preds = %96, %77
%97 = phi i64 [ 0, %77 ], [ %122, %96 ]
%98 = phi i64 [ 0, %77 ], [ %123, %96 ]
%99 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %97
%100 = load i8, i8* %99
%101 = shl nuw nsw i64 %97, 1
%102 = add nuw nsw i64 %101, 15
%103 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %102
store i8 %100, i8* %103
%104 = or i64 %97, 1
%105 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %104
%106 = load i8, i8* %105
%107 = shl nuw nsw i64 %104, 1
%108 = add nuw nsw i64 %107, 15
%109 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %108
store i8 %106, i8* %109
%110 = or i64 %97, 2
%111 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %110
%112 = load i8, i8* %111
%113 = shl nuw nsw i64 %110, 1
%114 = add nuw nsw i64 %113, 15
%115 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %114
store i8 %112, i8* %115
%116 = or i64 %97, 3
%117 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 %116
%118 = load i8, i8* %117
%119 = shl nuw nsw i64 %116, 1
%120 = add nuw nsw i64 %119, 15
%121 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %120
store i8 %118, i8* %121
%122 = add nuw nsw i64 %97, 4
%123 = add i64 %98, 4
%124 = icmp eq i64 %123, %78
br i1 %124, label %79, label %96
125: ; preds = %93, %125
%126 = phi i64 [ %135, %125 ], [ 0, %93 ]
%127 = getelementptr inbounds [99 x i8], [99 x i8]* %9, i64 0, i64 %126
%128 = load i8, i8* %127
%129 = trunc i64 %126 to i32
%130 = add i32 %55, %129
%131 = shl i32 %130, 1
%132 = add nsw i32 %131, 15
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %133
store i8 %128, i8* %134
%135 = add nuw nsw i64 %126, 1
%136 = call i32 @strlen(i8* %15)
%137 = sext i32 %136 to i64
%138 = icmp slt i64 %135, %137
br i1 %138, label %125, label %139
139: ; preds = %125, %93
br label %140
140: ; preds = %139, %140
%141 = phi i64 [ %163, %140 ], [ 0, %139 ]
%142 = phi i64 [ %159, %140 ], [ 0, %139 ]
%143 = phi i64 [ %160, %140 ], [ 0, %139 ]
%144 = phi i64 [ %161, %140 ], [ 0, %139 ]
%145 = phi i64 [ %162, %140 ], [ 0, %139 ]
%146 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %141
%147 = load i8, i8* %146
%148 = sext i8 %147 to i64
%149 = shl nuw i64 %145, 24
%150 = and i64 %149, 4278190080
%151 = shl nuw i64 %144, 16
%152 = and i64 %151, 16711680
%153 = or i64 %150, %152
%154 = shl nuw i64 %143, 8
%155 = and i64 %154, 65280
%156 = or i64 %153, %155
%157 = and i64 %142, 255
%158 = or i64 %156, %157
%159 = add nsw i64 %158, %148
%160 = lshr i64 %159, 8
%161 = lshr i64 %159, 16
%162 = lshr i64 %159, 24
%163 = add nuw nsw i64 %141, 1
%164 = icmp eq i64 %163, 252
br i1 %164, label %165, label %140
165: ; preds = %140
%166 = trunc i64 %159 to i8
%167 = trunc i64 %160 to i8
%168 = trunc i64 %161 to i8
%169 = trunc i64 %162 to i8
%170 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 252
store i8 %166, i8* %170
%171 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 253
store i8 %167, i8* %171
%172 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 254
store i8 %168, i8* %172
%173 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 255
store i8 %169, i8* %173
%174 = bitcast [256 x i8]* %3 to <16 x i8>*
%175 = load <16 x i8>, <16 x i8>* %174
%176 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 16
%177 = bitcast i8* %176 to <16 x i8>*
%178 = load <16 x i8>, <16 x i8>* %177
%179 = xor <16 x i8> %175, <i8 -121, i8 -10, i8 -95, i8 124, i8 -42, i8 58, i8 -121, i8 -26, i8 14, i8 -124, i8 -10, i8 -54, i8 -127, i8 -65, i8 118, i8 18>
%180 = xor <16 x i8> %178, <i8 -24, i8 61, i8 -9, i8 106, i8 41, i8 -61, i8 -124, i8 -75, i8 107, i8 -61, i8 74, i8 -113, i8 118, i8 -39, i8 -118, i8 118>
%181 = bitcast [256 x i8]* %6 to <16 x i8>*
store <16 x i8> %179, <16 x i8>* %181
%182 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 16
%183 = bitcast i8* %182 to <16 x i8>*
store <16 x i8> %180, <16 x i8>* %183
%184 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 32
%185 = bitcast i8* %184 to <16 x i8>*
%186 = load <16 x i8>, <16 x i8>* %185
%187 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 48
%188 = bitcast i8* %187 to <16 x i8>*
%189 = load <16 x i8>, <16 x i8>* %188
%190 = xor <16 x i8> %186, <i8 -94, i8 59, i8 -104, i8 -41, i8 -26, i8 -11, i8 -100, i8 -121, i8 108, i8 73, i8 -116, i8 125, i8 101, i8 -46, i8 -81, i8 23>
%191 = xor <16 x i8> %189, <i8 -118, i8 -42, i8 73, i8 -8, i8 122, i8 27, i8 35, i8 -100, i8 124, i8 -56, i8 -90, i8 25, i8 -18, i8 40, i8 127, i8 104>
%192 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 32
%193 = bitcast i8* %192 to <16 x i8>*
store <16 x i8> %190, <16 x i8>* %193
%194 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 48
%195 = bitcast i8* %194 to <16 x i8>*
store <16 x i8> %191, <16 x i8>* %195
%196 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 64
%197 = bitcast i8* %196 to <16 x i8>*
%198 = load <16 x i8>, <16 x i8>* %197
%199 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 80
%200 = bitcast i8* %199 to <16 x i8>*
%201 = load <16 x i8>, <16 x i8>* %200
%202 = xor <16 x i8> %198, <i8 72, i8 125, i8 -42, i8 90, i8 -77, i8 -116, i8 -9, i8 82, i8 -2, i8 50, i8 -39, i8 -124, i8 -89, i8 -91, i8 -55, i8 -121>
%203 = xor <16 x i8> %201, <i8 42, i8 -113, i8 -9, i8 109, i8 72, i8 125, i8 -26, i8 37, i8 -19, i8 84, i8 -101, i8 -61, i8 106, i8 -91, i8 -104, i8 100>
%204 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 64
%205 = bitcast i8* %204 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %205
%206 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 80
%207 = bitcast i8* %206 to <16 x i8>*
store <16 x i8> %203, <16 x i8>* %207
%208 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 96
%209 = bitcast i8* %208 to <16 x i8>*
%210 = load <16 x i8>, <16 x i8>* %209
%211 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 112
%212 = bitcast i8* %211 to <16 x i8>*
%213 = load <16 x i8>, <16 x i8>* %212
%214 = xor <16 x i8> %210, <i8 -84, i8 16, i8 -39, i8 -113, i8 -25, i8 48, i8 -87, i8 84, i8 -28, i8 92, i8 -44, i8 53, i8 -92, i8 53, i8 -1, i8 38>
%215 = xor <16 x i8> %213, <i8 79, i8 -121, i8 -22, i8 101, i8 59, i8 -34, i8 72, i8 118, i8 30, i8 -72, i8 114, i8 -59, i8 -40, i8 94, i8 -118, i8 36>
%216 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 96
%217 = bitcast i8* %216 to <16 x i8>*
store <16 x i8> %214, <16 x i8>* %217
%218 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 112
%219 = bitcast i8* %218 to <16 x i8>*
store <16 x i8> %215, <16 x i8>* %219
%220 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 128
%221 = bitcast i8* %220 to <16 x i8>*
%222 = load <16 x i8>, <16 x i8>* %221
%223 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 144
%224 = bitcast i8* %223 to <16 x i8>*
%225 = load <16 x i8>, <16 x i8>* %224
%226 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 128
%227 = bitcast i8* %226 to <16 x i8>*
store <16 x i8> %222, <16 x i8>* %227
%228 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 144
%229 = bitcast i8* %228 to <16 x i8>*
store <16 x i8> %225, <16 x i8>* %229
%230 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 160
%231 = bitcast i8* %230 to <16 x i8>*
%232 = load <16 x i8>, <16 x i8>* %231
%233 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 176
%234 = bitcast i8* %233 to <16 x i8>*
%235 = load <16 x i8>, <16 x i8>* %234
%236 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 160
%237 = bitcast i8* %236 to <16 x i8>*
store <16 x i8> %232, <16 x i8>* %237
%238 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 176
%239 = bitcast i8* %238 to <16 x i8>*
store <16 x i8> %235, <16 x i8>* %239
%240 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 192
%241 = bitcast i8* %240 to <16 x i8>*
%242 = load <16 x i8>, <16 x i8>* %241
%243 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 208
%244 = bitcast i8* %243 to <16 x i8>*
%245 = load <16 x i8>, <16 x i8>* %244
%246 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 192
%247 = bitcast i8* %246 to <16 x i8>*
store <16 x i8> %242, <16 x i8>* %247
%248 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 208
%249 = bitcast i8* %248 to <16 x i8>*
store <16 x i8> %245, <16 x i8>* %249
%250 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 224
%251 = bitcast i8* %250 to <8 x i8>*
%252 = load <8 x i8>, <8 x i8>* %251
%253 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 224
%254 = bitcast i8* %253 to <8 x i8>*
store <8 x i8> %252, <8 x i8>* %254
%255 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 232
%256 = bitcast i8* %255 to <8 x i8>*
%257 = load <8 x i8>, <8 x i8>* %256
%258 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 232
%259 = bitcast i8* %258 to <8 x i8>*
store <8 x i8> %257, <8 x i8>* %259
%260 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 240
%261 = bitcast i8* %260 to <8 x i8>*
%262 = load <8 x i8>, <8 x i8>* %261
%263 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 240
%264 = bitcast i8* %263 to <8 x i8>*
store <8 x i8> %262, <8 x i8>* %264
%265 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 248
%266 = load i8, i8* %265
%267 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 248
store i8 %266, i8* %267
%268 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 249
%269 = load i8, i8* %268
%270 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 249
store i8 %269, i8* %270
%271 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 250
%272 = load i8, i8* %271
%273 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 250
store i8 %272, i8* %273
%274 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 251
%275 = load i8, i8* %274
%276 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 251
store i8 %275, i8* %276
%277 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 252
%278 = load i8, i8* %277
%279 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 252
store i8 %278, i8* %279
%280 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 253
%281 = load i8, i8* %280
%282 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 253
store i8 %281, i8* %282
%283 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 254
%284 = load i8, i8* %283
%285 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 254
store i8 %284, i8* %285
%286 = load i32*, i32** @stdout
%287 = icmp eq i32* %286, null
br i1 %287, label %290, label %288
288: ; preds = %165
%289 = call i32 @fwrite(i8* %13, i32 1, i32 255, i32* %286)
br label %293
290: ; preds = %165
%291 = load i32, i32* @stderr
%292 = call i32 @fprintf(i32 %291, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
br label %293
293: ; preds = %288, %290, %17
%294 = phi i32 [ 2, %17 ], [ 0, %288 ], [ 1, %290 ]
ret i32 %294
}