#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 */
int /*<<< orphan*/ printf(char *, char, char, char, ...);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  char cr16[1000];
  char res3[1000];
  int cr10[1000];
  int res[1000];
  int res2[1000];
  int i = 0, j = 0, a = 10, b = 11, c = 12, d = 13, e = 14, f = 15;
  char type;
  scanf("%c%*c", &type);
  if (type == 'h') {
    scanf("%*c%c", &cr16[i]);
    scanf("%c", &cr16[i + 1]);
    scanf("%c", &cr16[i + 2]);
    scanf("%c", &cr16[i + 3]);
    scanf("%c", &cr16[i + 4]);
    scanf("%c", &cr16[i + 5]);
    scanf("%c", &cr16[i + 6]);
    while (i <= 5) {
      if (cr16[i] == '0')
        res[i] = 0;
      if (cr16[i] == '1')
        res[i] = 1;
      if (cr16[i] == '2')
        res[i] = 2;
      if (cr16[i] == '3')
        res[i] = 3;
      if (cr16[i] == '4')
        res[i] = 4;
      if (cr16[i] == '5')
        res[i] = 5;
      if (cr16[i] == '6')
        res[i] = 6;
      if (cr16[i] == '7')
        res[i] = 7;
      if (cr16[i] == '8')
        res[i] = 8;
      if (cr16[i] == '9')
        res[i] = 9;
      if (cr16[i] == 'a')
        res[i] = 10;
      if (cr16[i] == 'b')
        res[i] = 11;
      if (cr16[i] == 'c')
        res[i] = 12;
      if (cr16[i] == 'd')
        res[i] = 13;
      if (cr16[i] == 'e')
        res[i] = 14;
      if (cr16[i] == 'f')
        res[i] = 15;
      i++;
    }
    i = 0;
    res2[i] = res[i] * 16 + res[i + 1];
    res2[i + 1] = res[i + 2] * 16 + res[i + 3];
    res2[i + 2] = res[i + 4] * 16 + res[i + 5];
    printf("rgb(%d, %d, %d)", res2[i], res2[i + 1], res2[i + 2]);
  }
  if (type == 'd') {
    scanf("%d, %d, %d", &cr10[i], &cr10[i + 1], &cr10[i + 2]);
    res[i] = cr10[i] / 16;
    res[i + 1] = cr10[i] % 16;
    res[i + 2] = cr10[i + 1] / 16;
    res[i + 3] = cr10[i + 1] % 16;
    res[i + 4] = cr10[i + 2] / 16;
    res[i + 5] = cr10[i + 2] % 16;
    for (i = 0; i <= 5; i++) {
      if (res[i] == 0)
        res3[i] = '0';
      if (res[i] == 1)
        res3[i] = '1';
      if (res[i] == 2)
        res3[i] = '2';
      if (res[i] == 3)
        res3[i] = '3';
      if (res[i] == 4)
        res3[i] = '4';
      if (res[i] == 5)
        res3[i] = '5';
      if (res[i] == 6)
        res3[i] = '6';
      if (res[i] == 7)
        res3[i] = '7';
      if (res[i] == 8)
        res3[i] = '8';
      if (res[i] == 9)
        res3[i] = '9';
      if (res[i] == 10)
        res3[i] = 'a';
      if (res[i] == 11)
        res3[i] = 'b';
      if (res[i] == 12)
        res3[i] = 'c';
      if (res[i] == 13)
        res3[i] = 'd';
      if (res[i] == 14)
        res3[i] = 'e';
      if (res[i] == 15)
        res3[i] = 'f';
    }
    i = 0;
    printf("#%c%c%c%c%c%c", res3[i], res3[i + 1], res3[i + 2], res3[i + 3],
           res3[i + 4], res3[i + 5]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x36f0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x36c4(%rbp)
movl   $0x0,-0x36c8(%rbp)
movl   $0xa,-0x36cc(%rbp)
movl   $0xb,-0x36d0(%rbp)
movl   $0xc,-0x36d4(%rbp)
movl   $0xd,-0x36d8(%rbp)
movl   $0xe,-0x36dc(%rbp)
movl   $0xf,-0x36e0(%rbp)
lea    0xe77(%rip),%rdi
lea    -0x36e1(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
movsbl -0x36e1(%rbp),%eax
cmp    $0x68,%eax
jne    1653 <main+0x533>
movslq -0x36c4(%rbp),%rax
lea    -0x3f0(%rbp),%rsi
add    %rax,%rsi
lea    0xe47(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
lea    -0x3f0(%rbp),%rsi
add    %rax,%rsi
lea    0xe50(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
lea    -0x3f0(%rbp),%rsi
add    %rax,%rsi
lea    0xe2d(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x36c4(%rbp),%eax
add    $0x3,%eax
cltq
lea    -0x3f0(%rbp),%rsi
add    %rax,%rsi
lea    0xe0a(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x36c4(%rbp),%eax
add    $0x4,%eax
cltq
lea    -0x3f0(%rbp),%rsi
add    %rax,%rsi
lea    0xde7(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x36c4(%rbp),%eax
add    $0x5,%eax
cltq
lea    -0x3f0(%rbp),%rsi
add    %rax,%rsi
lea    0xdc4(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x36c4(%rbp),%eax
add    $0x6,%eax
cltq
lea    -0x3f0(%rbp),%rsi
add    %rax,%rsi
lea    0xda1(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
cmpl   $0x5,-0x36c4(%rbp)
jg     1559 <main+0x439>
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x30,%eax
jne    12cf <main+0x1af>
movslq -0x36c4(%rbp),%rax
movl   $0x0,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    12f9 <main+0x1d9>
movslq -0x36c4(%rbp),%rax
movl   $0x1,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x32,%eax
jne    1323 <main+0x203>
movslq -0x36c4(%rbp),%rax
movl   $0x2,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x33,%eax
jne    134d <main+0x22d>
movslq -0x36c4(%rbp),%rax
movl   $0x3,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x34,%eax
jne    1377 <main+0x257>
movslq -0x36c4(%rbp),%rax
movl   $0x4,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x35,%eax
jne    13a1 <main+0x281>
movslq -0x36c4(%rbp),%rax
movl   $0x5,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x36,%eax
jne    13cb <main+0x2ab>
movslq -0x36c4(%rbp),%rax
movl   $0x6,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x37,%eax
jne    13f5 <main+0x2d5>
movslq -0x36c4(%rbp),%rax
movl   $0x7,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x38,%eax
jne    141f <main+0x2ff>
movslq -0x36c4(%rbp),%rax
movl   $0x8,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x39,%eax
jne    1449 <main+0x329>
movslq -0x36c4(%rbp),%rax
movl   $0x9,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x61,%eax
jne    1473 <main+0x353>
movslq -0x36c4(%rbp),%rax
movl   $0xa,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x62,%eax
jne    149d <main+0x37d>
movslq -0x36c4(%rbp),%rax
movl   $0xb,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x63,%eax
jne    14c7 <main+0x3a7>
movslq -0x36c4(%rbp),%rax
movl   $0xc,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x64,%eax
jne    14f1 <main+0x3d1>
movslq -0x36c4(%rbp),%rax
movl   $0xd,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x65,%eax
jne    151b <main+0x3fb>
movslq -0x36c4(%rbp),%rax
movl   $0xe,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x66,%eax
jne    1545 <main+0x425>
movslq -0x36c4(%rbp),%rax
movl   $0xf,-0x2720(%rbp,%rax,4)
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x36c4(%rbp)
jmp    1298 <main+0x178>
movl   $0x0,-0x36c4(%rbp)
movslq -0x36c4(%rbp),%rax
mov    -0x2720(%rbp,%rax,4),%ecx
shl    $0x4,%ecx
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
add    -0x2720(%rbp,%rax,4),%ecx
movslq -0x36c4(%rbp),%rax
mov    %ecx,-0x36c0(%rbp,%rax,4)
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x2720(%rbp,%rax,4),%ecx
shl    $0x4,%ecx
mov    -0x36c4(%rbp),%eax
add    $0x3,%eax
cltq
add    -0x2720(%rbp,%rax,4),%ecx
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x36c0(%rbp,%rax,4)
mov    -0x36c4(%rbp),%eax
add    $0x4,%eax
cltq
mov    -0x2720(%rbp,%rax,4),%ecx
shl    $0x4,%ecx
mov    -0x36c4(%rbp),%eax
add    $0x5,%eax
cltq
add    -0x2720(%rbp,%rax,4),%ecx
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
mov    %ecx,-0x36c0(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
mov    -0x36c0(%rbp,%rax,4),%eax
mov    %al,%dl
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x36c0(%rbp,%rax,4),%eax
mov    %al,%cl
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x36c0(%rbp,%rax,4),%eax
lea    0x9c9(%rip),%rdi
movsbl %dl,%esi
movsbl %cl,%edx
movsbl %al,%ecx
mov    $0x0,%al
call   1030 <printf@plt>
movsbl -0x36e1(%rbp),%eax
cmp    $0x64,%eax
jne    1abd <main+0x99d>
movslq -0x36c4(%rbp),%rax
lea    -0x1780(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
lea    -0x1780(%rbp),%rdx
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
lea    -0x1780(%rbp),%rcx
shl    $0x2,%rax
add    %rax,%rcx
lea    0x96b(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
movslq -0x36c4(%rbp),%rax
mov    -0x1780(%rbp,%rax,4),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
movslq -0x36c4(%rbp),%rax
mov    %ecx,-0x2720(%rbp,%rax,4)
movslq -0x36c4(%rbp),%rax
mov    -0x1780(%rbp,%rax,4),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
mov    %edx,-0x2720(%rbp,%rax,4)
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x1780(%rbp,%rax,4),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
mov    %ecx,-0x2720(%rbp,%rax,4)
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x1780(%rbp,%rax,4),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    -0x36c4(%rbp),%eax
add    $0x3,%eax
cltq
mov    %edx,-0x2720(%rbp,%rax,4)
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x1780(%rbp,%rax,4),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x36c4(%rbp),%eax
add    $0x4,%eax
cltq
mov    %ecx,-0x2720(%rbp,%rax,4)
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x1780(%rbp,%rax,4),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    -0x36c4(%rbp),%eax
add    $0x5,%eax
cltq
mov    %edx,-0x2720(%rbp,%rax,4)
movl   $0x0,-0x36c4(%rbp)
cmpl   $0x5,-0x36c4(%rbp)
jg     1a2a <main+0x90a>
movslq -0x36c4(%rbp),%rax
cmpl   $0x0,-0x2720(%rbp,%rax,4)
jne    17f5 <main+0x6d5>
movslq -0x36c4(%rbp),%rax
movb   $0x30,-0x7e0(%rbp,%rax,1)
30
movslq -0x36c4(%rbp),%rax
cmpl   $0x1,-0x2720(%rbp,%rax,4)
01
jne    1819 <main+0x6f9>
movslq -0x36c4(%rbp),%rax
movb   $0x31,-0x7e0(%rbp,%rax,1)
31
movslq -0x36c4(%rbp),%rax
cmpl   $0x2,-0x2720(%rbp,%rax,4)
02
jne    183d <main+0x71d>
movslq -0x36c4(%rbp),%rax
movb   $0x32,-0x7e0(%rbp,%rax,1)
32
movslq -0x36c4(%rbp),%rax
cmpl   $0x3,-0x2720(%rbp,%rax,4)
03
jne    1861 <main+0x741>
movslq -0x36c4(%rbp),%rax
movb   $0x33,-0x7e0(%rbp,%rax,1)
33
movslq -0x36c4(%rbp),%rax
cmpl   $0x4,-0x2720(%rbp,%rax,4)
04
jne    1885 <main+0x765>
movslq -0x36c4(%rbp),%rax
movb   $0x34,-0x7e0(%rbp,%rax,1)
34
movslq -0x36c4(%rbp),%rax
cmpl   $0x5,-0x2720(%rbp,%rax,4)
05
jne    18a9 <main+0x789>
movslq -0x36c4(%rbp),%rax
movb   $0x35,-0x7e0(%rbp,%rax,1)
35
movslq -0x36c4(%rbp),%rax
cmpl   $0x6,-0x2720(%rbp,%rax,4)
06
jne    18cd <main+0x7ad>
movslq -0x36c4(%rbp),%rax
movb   $0x36,-0x7e0(%rbp,%rax,1)
36
movslq -0x36c4(%rbp),%rax
cmpl   $0x7,-0x2720(%rbp,%rax,4)
07
jne    18f1 <main+0x7d1>
movslq -0x36c4(%rbp),%rax
movb   $0x37,-0x7e0(%rbp,%rax,1)
37
movslq -0x36c4(%rbp),%rax
cmpl   $0x8,-0x2720(%rbp,%rax,4)
08
jne    1915 <main+0x7f5>
movslq -0x36c4(%rbp),%rax
movb   $0x38,-0x7e0(%rbp,%rax,1)
38
movslq -0x36c4(%rbp),%rax
cmpl   $0x9,-0x2720(%rbp,%rax,4)
09
jne    1939 <main+0x819>
movslq -0x36c4(%rbp),%rax
movb   $0x39,-0x7e0(%rbp,%rax,1)
39
movslq -0x36c4(%rbp),%rax
cmpl   $0xa,-0x2720(%rbp,%rax,4)
0a
jne    195d <main+0x83d>
movslq -0x36c4(%rbp),%rax
movb   $0x61,-0x7e0(%rbp,%rax,1)
61
movslq -0x36c4(%rbp),%rax
cmpl   $0xb,-0x2720(%rbp,%rax,4)
0b
jne    1981 <main+0x861>
movslq -0x36c4(%rbp),%rax
movb   $0x62,-0x7e0(%rbp,%rax,1)
62
movslq -0x36c4(%rbp),%rax
cmpl   $0xc,-0x2720(%rbp,%rax,4)
0c
jne    19a5 <main+0x885>
movslq -0x36c4(%rbp),%rax
movb   $0x63,-0x7e0(%rbp,%rax,1)
63
movslq -0x36c4(%rbp),%rax
cmpl   $0xd,-0x2720(%rbp,%rax,4)
0d
jne    19c9 <main+0x8a9>
movslq -0x36c4(%rbp),%rax
movb   $0x64,-0x7e0(%rbp,%rax,1)
64
movslq -0x36c4(%rbp),%rax
cmpl   $0xe,-0x2720(%rbp,%rax,4)
0e
jne    19ed <main+0x8cd>
movslq -0x36c4(%rbp),%rax
movb   $0x65,-0x7e0(%rbp,%rax,1)
65
movslq -0x36c4(%rbp),%rax
cmpl   $0xf,-0x2720(%rbp,%rax,4)
0f
jne    1a11 <main+0x8f1>
movslq -0x36c4(%rbp),%rax
movb   $0x66,-0x7e0(%rbp,%rax,1)
66
jmp    1a16 <main+0x8f6>
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x36c4(%rbp)
jmp    17c4 <main+0x6a4>
movl   $0x0,-0x36c4(%rbp)
movslq -0x36c4(%rbp),%rax
mov    -0x7e0(%rbp,%rax,1),%sil
ff
mov    -0x36c4(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x7e0(%rbp,%rax,1),%dl
mov    -0x36c4(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x7e0(%rbp,%rax,1),%cl
mov    -0x36c4(%rbp),%eax
add    $0x3,%eax
cltq
movsbl -0x7e0(%rbp,%rax,1),%r8d
ff ff
mov    -0x36c4(%rbp),%eax
add    $0x4,%eax
cltq
movsbl -0x7e0(%rbp,%rax,1),%r9d
ff ff
mov    -0x36c4(%rbp),%eax
add    $0x5,%eax
cltq
movsbl -0x7e0(%rbp,%rax,1),%eax
ff
lea    0x57e(%rip),%rdi
movsbl %sil,%esi
movsbl %dl,%edx
movsbl %cl,%ecx
mov    %eax,(%rsp)
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x36f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
sub    $0x2738,%rsp
lea    0x13f8(%rip),%rdi
xor    %ebp,%ebp
lea    0xf(%rsp),%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
mov    0xf(%rsp),%al
cmp    $0x68,%al
jne    157b <main+0x45b>
lea    0x13dd(%rip),%rdi
lea    0x10(%rsp),%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0x11(%rsp),%rsi
lea    0x13f1(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0x12(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0x13(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0x14(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0x15(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0x16(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
mov    0x10(%rsp),%al
add    $0xd0,%al
cmp    $0x36,%al
ja     124d <main+0x12d>
movzbl %al,%eax
lea    0xe2a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    $0x1,%ebp
jmp    1246 <main+0x126>
mov    $0x2,%ebp
jmp    1246 <main+0x126>
mov    $0x3,%ebp
jmp    1246 <main+0x126>
mov    $0x4,%ebp
jmp    1246 <main+0x126>
mov    $0x5,%ebp
jmp    1246 <main+0x126>
mov    $0x6,%ebp
jmp    1246 <main+0x126>
mov    $0x7,%ebp
jmp    1246 <main+0x126>
mov    $0x8,%ebp
jmp    1246 <main+0x126>
mov    $0x9,%ebp
jmp    1246 <main+0x126>
mov    $0xa,%ebp
jmp    1246 <main+0x126>
mov    $0xb,%ebp
jmp    1246 <main+0x126>
mov    $0xc,%ebp
jmp    1246 <main+0x126>
mov    $0xd,%ebp
jmp    1246 <main+0x126>
mov    $0xe,%ebp
jmp    1246 <main+0x126>
mov    $0xf,%ebp
mov    %ebp,0x7f0(%rsp)
mov    0x11(%rsp),%cl
add    $0xd0,%cl
cmp    $0x36,%cl
ja     12e0 <main+0x1c0>
xor    %eax,%eax
movzbl %cl,%ecx
lea    0xe73(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    $0x1,%eax
jmp    12d9 <main+0x1b9>
mov    $0x2,%eax
jmp    12d9 <main+0x1b9>
mov    $0x3,%eax
jmp    12d9 <main+0x1b9>
mov    $0x4,%eax
jmp    12d9 <main+0x1b9>
mov    $0x5,%eax
jmp    12d9 <main+0x1b9>
mov    $0x6,%eax
jmp    12d9 <main+0x1b9>
mov    $0x7,%eax
jmp    12d9 <main+0x1b9>
mov    $0x8,%eax
jmp    12d9 <main+0x1b9>
mov    $0x9,%eax
jmp    12d9 <main+0x1b9>
mov    $0xa,%eax
jmp    12d9 <main+0x1b9>
mov    $0xb,%eax
jmp    12d9 <main+0x1b9>
mov    $0xc,%eax
jmp    12d9 <main+0x1b9>
mov    $0xd,%eax
jmp    12d9 <main+0x1b9>
mov    $0xe,%eax
jmp    12d9 <main+0x1b9>
mov    $0xf,%eax
mov    %eax,0x7f4(%rsp)
mov    0x12(%rsp),%cl
add    $0xd0,%cl
cmp    $0x36,%cl
ja     1373 <main+0x253>
xor    %eax,%eax
movzbl %cl,%ecx
lea    0xebc(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    $0x1,%eax
jmp    136c <main+0x24c>
mov    $0x2,%eax
jmp    136c <main+0x24c>
mov    $0x3,%eax
jmp    136c <main+0x24c>
mov    $0x4,%eax
jmp    136c <main+0x24c>
mov    $0x5,%eax
jmp    136c <main+0x24c>
mov    $0x6,%eax
jmp    136c <main+0x24c>
mov    $0x7,%eax
jmp    136c <main+0x24c>
mov    $0x8,%eax
jmp    136c <main+0x24c>
mov    $0x9,%eax
jmp    136c <main+0x24c>
mov    $0xa,%eax
jmp    136c <main+0x24c>
mov    $0xb,%eax
jmp    136c <main+0x24c>
mov    $0xc,%eax
jmp    136c <main+0x24c>
mov    $0xd,%eax
jmp    136c <main+0x24c>
mov    $0xe,%eax
jmp    136c <main+0x24c>
mov    $0xf,%eax
mov    %eax,0x7f8(%rsp)
mov    0x13(%rsp),%cl
add    $0xd0,%cl
cmp    $0x36,%cl
ja     1406 <main+0x2e6>
xor    %eax,%eax
movzbl %cl,%ecx
lea    0xf05(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    $0x1,%eax
jmp    13ff <main+0x2df>
mov    $0x2,%eax
jmp    13ff <main+0x2df>
mov    $0x3,%eax
jmp    13ff <main+0x2df>
mov    $0x4,%eax
jmp    13ff <main+0x2df>
mov    $0x5,%eax
jmp    13ff <main+0x2df>
mov    $0x6,%eax
jmp    13ff <main+0x2df>
mov    $0x7,%eax
jmp    13ff <main+0x2df>
mov    $0x8,%eax
jmp    13ff <main+0x2df>
mov    $0x9,%eax
jmp    13ff <main+0x2df>
mov    $0xa,%eax
jmp    13ff <main+0x2df>
mov    $0xb,%eax
jmp    13ff <main+0x2df>
mov    $0xc,%eax
jmp    13ff <main+0x2df>
mov    $0xd,%eax
jmp    13ff <main+0x2df>
mov    $0xe,%eax
jmp    13ff <main+0x2df>
mov    $0xf,%eax
mov    %eax,0x7fc(%rsp)
mov    0x14(%rsp),%cl
add    $0xd0,%cl
cmp    $0x36,%cl
ja     1499 <main+0x379>
xor    %eax,%eax
movzbl %cl,%ecx
lea    0xf4e(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    $0x1,%eax
jmp    1492 <main+0x372>
mov    $0x2,%eax
jmp    1492 <main+0x372>
mov    $0x3,%eax
jmp    1492 <main+0x372>
mov    $0x4,%eax
jmp    1492 <main+0x372>
mov    $0x5,%eax
jmp    1492 <main+0x372>
mov    $0x6,%eax
jmp    1492 <main+0x372>
mov    $0x7,%eax
jmp    1492 <main+0x372>
mov    $0x8,%eax
jmp    1492 <main+0x372>
mov    $0x9,%eax
jmp    1492 <main+0x372>
mov    $0xa,%eax
jmp    1492 <main+0x372>
mov    $0xb,%eax
jmp    1492 <main+0x372>
mov    $0xc,%eax
jmp    1492 <main+0x372>
mov    $0xd,%eax
jmp    1492 <main+0x372>
mov    $0xe,%eax
jmp    1492 <main+0x372>
mov    $0xf,%eax
mov    %eax,0x800(%rsp)
mov    0x15(%rsp),%cl
add    $0xd0,%cl
cmp    $0x36,%cl
ja     152c <main+0x40c>
xor    %eax,%eax
movzbl %cl,%ecx
lea    0xf97(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    $0x1,%eax
jmp    1525 <main+0x405>
mov    $0x2,%eax
jmp    1525 <main+0x405>
mov    $0x3,%eax
jmp    1525 <main+0x405>
mov    $0x4,%eax
jmp    1525 <main+0x405>
mov    $0x5,%eax
jmp    1525 <main+0x405>
mov    $0x6,%eax
jmp    1525 <main+0x405>
mov    $0x7,%eax
jmp    1525 <main+0x405>
mov    $0x8,%eax
jmp    1525 <main+0x405>
mov    $0x9,%eax
jmp    1525 <main+0x405>
mov    $0xa,%eax
jmp    1525 <main+0x405>
mov    $0xb,%eax
jmp    1525 <main+0x405>
mov    $0xc,%eax
jmp    1525 <main+0x405>
mov    $0xd,%eax
jmp    1525 <main+0x405>
mov    $0xe,%eax
jmp    1525 <main+0x405>
mov    $0xf,%eax
mov    %eax,0x804(%rsp)
mov    0x7f0(%rsp),%eax
shl    $0x4,%eax
add    0x7f4(%rsp),%eax
mov    0x7f8(%rsp),%ecx
shl    $0x4,%ecx
add    0x7fc(%rsp),%ecx
mov    0x800(%rsp),%edi
shl    $0x4,%edi
add    0x804(%rsp),%edi
movsbl %al,%esi
movsbl %cl,%edx
movsbl %dil,%ecx
lea    0xfc4(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    0xf(%rsp),%al
cmp    $0x64,%al
jne    1714 <main+0x5f4>
lea    0x1794(%rsp),%rdx
lea    0x1798(%rsp),%rcx
lea    0xfaa(%rip),%rdi
lea    0x1790(%rsp),%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
mov    0x1790(%rsp),%ecx
mov    0x1794(%rsp),%edx
lea    0xf(%rcx),%esi
test   %ecx,%ecx
cmovns %ecx,%esi
mov    %esi,%eax
sar    $0x4,%eax
mov    %eax,0x7f0(%rsp)
and    $0xfffffff0,%esi
sub    %esi,%ecx
mov    %ecx,0x7f4(%rsp)
lea    0xf(%rdx),%ecx
test   %edx,%edx
cmovns %edx,%ecx
mov    %ecx,%esi
sar    $0x4,%esi
mov    %esi,0x7f8(%rsp)
and    $0xfffffff0,%ecx
sub    %ecx,%edx
mov    %edx,0x7fc(%rsp)
mov    0x1798(%rsp),%ecx
lea    0xf(%rcx),%edx
test   %ecx,%ecx
cmovns %ecx,%edx
mov    %edx,%esi
sar    $0x4,%esi
mov    %esi,0x800(%rsp)
and    $0xfffffff0,%edx
sub    %edx,%ecx
mov    %ecx,0x804(%rsp)
cmp    $0xf,%eax
ja     1636 <main+0x516>
cltq
lea    0xf31(%rip),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,0x400(%rsp)
movslq 0x7f4(%rsp),%rax
cmp    $0xf,%rax
ja     1655 <main+0x535>
lea    0xf12(%rip),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,0x401(%rsp)
movslq 0x7f8(%rsp),%rax
cmp    $0xf,%rax
ja     1674 <main+0x554>
lea    0xef3(%rip),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,0x402(%rsp)
movslq 0x7fc(%rsp),%rax
cmp    $0xf,%rax
ja     1693 <main+0x573>
lea    0xed4(%rip),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,0x403(%rsp)
movslq 0x800(%rsp),%rax
cmp    $0xf,%rax
ja     16b2 <main+0x592>
lea    0xeb5(%rip),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,0x404(%rsp)
movslq 0x804(%rsp),%rax
cmp    $0xf,%rax
ja     16d1 <main+0x5b1>
lea    0xe96(%rip),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,0x405(%rsp)
movsbl 0x400(%rsp),%esi
movsbl 0x401(%rsp),%edx
movsbl 0x402(%rsp),%ecx
movsbl 0x403(%rsp),%r8d
movsbl 0x404(%rsp),%r9d
movsbl 0x405(%rsp),%eax
mov    %eax,(%rsp)
lea    0xe42(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x2738,%rsp
pop    %rbx
pop    %rbp
ret

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

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