#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 *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int main(void) {
  int a;
  char ch_a[8 + 1];
  int b;
  char ch_b[8 + 1];
  int t;
  int i;
  int x;
  char ch_x[8 + 1];
  int y;
  char ch_y[8 + 1];
  unsigned int nx;
  unsigned int ut;
  char ch_nx[32 + 1];
  int xab;
  char ch_xab[8 + 1];
  int rx;
  char ch_rx[8 + 1];
  int lx;
  char ch_lx[8 + 1];
  printf("a: ");
  scanf("%d", &a);
  printf("b: ");
  scanf("%d", &b);
  t = a;
  printf("a(2) = ");
  for (i = 7; i >= 0; i--) {
    ch_a[i] = '0' + t % 2;
    t = t / 2;
  }
  ch_a[8] = '\0';
  printf("%s\n", ch_a);
  t = b;
  printf("b(2) = ");
  for (i = 7; i >= 0; i--) {
    ch_b[i] = '0' + t % 2;
    t = t / 2;
  }
  ch_b[8] = '\0';
  printf("%s\n", ch_b);
  x = a | b;
  t = x;
  printf("x(2) = ");
  for (i = 7; i >= 0; i--) {
    ch_x[i] = '0' + t % 2;
    t = t / 2;
  }
  ch_x[8] = '\0';
  printf("%s\n", ch_x);
  y = a & b;
  t = y;
  printf("y(2) = ");
  for (i = 7; i >= 0; i--) {
    ch_y[i] = '0' + t % 2;
    t = t / 2;
  }
  ch_y[8] = '\0';
  printf("%s\n", ch_y);
  nx = (unsigned int)~x;
  ut = nx;
  printf("nx(2) = ");
  for (i = 31; i >= 0; i--) {
    ch_nx[i] = '0' + ut % 2;
    ut = ut / 2;
  }
  ch_nx[32] = '\0';
  printf("%s\n", ch_nx);
  xab = a ^ b;
  t = xab;
  printf("xab(2) = ");
  for (i = 7; i >= 0; i--) {
    ch_xab[i] = '0' + t % 2;
    t = t / 2;
  }
  ch_xab[8] = '\0';
  printf("%s\n", ch_xab);
  rx = x >> 2;
  t = rx;
  printf("rx(2) = ");
  for (i = 7; i >= 0; i--) {
    ch_rx[i] = '0' + t % 2;
    t = t / 2;
  }
  ch_rx[8] = '\0';
  printf("%s\n", ch_rx);
  lx = x << 2;
  t = lx;
  printf("lx(2) = ");
  for (i = 7; i >= 0; i--) {
    ch_lx[i] = '0' + t % 2;
    t = t / 2;
  }
  ch_lx[8] = '\0';
  printf("%s\n", ch_lx);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xebd(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
lea    0xeb0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xe9f(%rip),%rdi
lea    -0x18(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
lea    0xe90(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     11c7 <main+0xa7>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x11(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1189 <main+0x69>
movb   $0x0,-0x9(%rbp)
lea    -0x11(%rbp),%rsi
lea    0xe3d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%eax
mov    %eax,-0x28(%rbp)
lea    0xe40(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1236 <main+0x116>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x21(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f8 <main+0xd8>
movb   $0x0,-0x19(%rbp)
lea    -0x21(%rbp),%rsi
lea    0xdce(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
or     -0x18(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x28(%rbp)
lea    0xdda(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     12ae <main+0x18e>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x39(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1270 <main+0x150>
movb   $0x0,-0x31(%rbp)
lea    -0x39(%rbp),%rsi
lea    0xd56(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
and    -0x18(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x28(%rbp)
lea    0xd3d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1326 <main+0x206>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x49(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    12e8 <main+0x1c8>
movb   $0x0,-0x41(%rbp)
lea    -0x49(%rbp),%rsi
lea    0xcde(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
lea    0xccd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1f,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1394 <main+0x274>
mov    -0x54(%rbp),%eax
and    $0x1,%eax
add    $0x30,%eax
mov    %al,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x54(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1360 <main+0x240>
movb   $0x0,-0x60(%rbp)
lea    -0x80(%rbp),%rsi
lea    0xc70(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x28(%rbp)
lea    0xc62(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1415 <main+0x2f5>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x8d(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    13d4 <main+0x2b4>
movb   $0x0,-0x85(%rbp)
lea    -0x8d(%rbp),%rsi
lea    0xbe9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x28(%rbp)
lea    0xbe5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     149c <main+0x37c>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x9d(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    145b <main+0x33b>
movb   $0x0,-0x95(%rbp)
lea    -0x9d(%rbp),%rsi
lea    0xb62(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0x28(%rbp)
lea    0xb67(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1523 <main+0x403>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0xad(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    14e2 <main+0x3c2>
movb   $0x0,-0xa5(%rbp)
lea    -0xad(%rbp),%rsi
lea    0xadb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
lea    0xeb8(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeae(%rip),%rbx
lea    0xc(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0xe9d(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x8(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
mov    0xc(%rsp),%ebp
lea    0x7f(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
mov    %eax,0x58(%rsp)
lea    0x3f(%rbp),%r15d
test   %ebp,%ebp
cmovns %ebp,%r15d
lea    0x1f(%rbp),%r12d
test   %ebp,%ebp
cmovns %ebp,%r12d
lea    0xf(%rbp),%r13d
test   %ebp,%ebp
cmovns %ebp,%r13d
lea    0x7(%rbp),%ebx
test   %ebp,%ebp
cmovns %ebp,%ebx
lea    0x3(%rbp),%r14d
test   %ebp,%ebp
lea    0xe4a(%rip),%rdi
cmovns %ebp,%r14d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
mov    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%ebp
add    $0x30,%bpl
mov    %bpl,0x46(%rsp)
mov    %eax,%ecx
sar    %ecx
shr    $0x1f,%eax
add    %ecx,%eax
and    $0xfe,%eax
sub    %eax,%ecx
add    $0x30,%cl
mov    %cl,0x45(%rsp)
mov    %r14d,%eax
sar    $0x2,%eax
shr    $0x1f,%r14d
add    %eax,%r14d
and    $0xfe,%r14d
sub    %r14d,%eax
add    $0x30,%al
mov    %al,0x44(%rsp)
mov    %ebx,%eax
sar    $0x3,%eax
shr    $0x1f,%ebx
add    %eax,%ebx
and    $0xfe,%ebx
sub    %ebx,%eax
add    $0x30,%al
mov    %al,0x43(%rsp)
mov    %r13d,%eax
sar    $0x4,%eax
shr    $0x1f,%r13d
add    %eax,%r13d
and    $0xfe,%r13d
sub    %r13d,%eax
add    $0x30,%al
mov    %al,0x42(%rsp)
mov    %r12d,%eax
sar    $0x5,%eax
shr    $0x1f,%r12d
add    %eax,%r12d
and    $0xfe,%r12d
sub    %r12d,%eax
add    $0x30,%al
mov    %al,0x41(%rsp)
mov    %r15d,%eax
sar    $0x6,%eax
shr    $0x1f,%r15d
add    %eax,%r15d
and    $0xfe,%r15d
sub    %r15d,%eax
add    $0x30,%al
mov    %al,0x40(%rsp)
mov    0x58(%rsp),%ecx
mov    %ecx,%eax
sar    $0x7,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x3f(%rsp)
movb   $0x0,0x47(%rsp)
lea    0x3f(%rsp),%rdi
call   1030 <puts@plt>
mov    0x8(%rsp),%ebp
lea    0x7f(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
mov    %eax,0x58(%rsp)
lea    0x3f(%rbp),%r15d
test   %ebp,%ebp
cmovns %ebp,%r15d
lea    0x1f(%rbp),%r12d
test   %ebp,%ebp
cmovns %ebp,%r12d
lea    0xf(%rbp),%r13d
test   %ebp,%ebp
cmovns %ebp,%r13d
lea    0x7(%rbp),%ebx
test   %ebp,%ebp
cmovns %ebp,%ebx
lea    0x3(%rbp),%r14d
test   %ebp,%ebp
lea    0xd2f(%rip),%rdi
cmovns %ebp,%r14d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
mov    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%ebp
add    $0x30,%bpl
mov    %bpl,0x3d(%rsp)
mov    %eax,%ecx
sar    %ecx
shr    $0x1f,%eax
add    %ecx,%eax
and    $0xfe,%eax
sub    %eax,%ecx
add    $0x30,%cl
mov    %cl,0x3c(%rsp)
mov    %r14d,%eax
sar    $0x2,%eax
shr    $0x1f,%r14d
add    %eax,%r14d
and    $0xfe,%r14d
sub    %r14d,%eax
add    $0x30,%al
mov    %al,0x3b(%rsp)
mov    %ebx,%eax
sar    $0x3,%eax
shr    $0x1f,%ebx
add    %eax,%ebx
and    $0xfe,%ebx
sub    %ebx,%eax
add    $0x30,%al
mov    %al,0x3a(%rsp)
mov    %r13d,%eax
sar    $0x4,%eax
shr    $0x1f,%r13d
add    %eax,%r13d
and    $0xfe,%r13d
sub    %r13d,%eax
add    $0x30,%al
mov    %al,0x39(%rsp)
mov    %r12d,%eax
sar    $0x5,%eax
shr    $0x1f,%r12d
add    %eax,%r12d
and    $0xfe,%r12d
sub    %r12d,%eax
add    $0x30,%al
mov    %al,0x38(%rsp)
mov    %r15d,%eax
sar    $0x6,%eax
shr    $0x1f,%r15d
add    %eax,%r15d
and    $0xfe,%r15d
sub    %r15d,%eax
add    $0x30,%al
mov    %al,0x37(%rsp)
mov    0x58(%rsp),%ecx
mov    %ecx,%eax
sar    $0x7,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x36(%rsp)
movb   $0x0,0x3e(%rsp)
lea    0x36(%rsp),%rdi
call   1030 <puts@plt>
mov    0x8(%rsp),%r15d
or     0xc(%rsp),%r15d
lea    0x7f(%r15),%eax
test   %r15d,%r15d
cmovns %r15d,%eax
mov    %eax,0x4(%rsp)
lea    0x3f(%r15),%r14d
test   %r15d,%r15d
cmovns %r15d,%r14d
lea    0x1f(%r15),%r12d
test   %r15d,%r15d
cmovns %r15d,%r12d
lea    0xf(%r15),%r13d
test   %r15d,%r15d
cmovns %r15d,%r13d
lea    0x7(%r15),%ebx
test   %r15d,%r15d
cmovns %r15d,%ebx
lea    0x3(%r15),%ebp
test   %r15d,%r15d
lea    0xbfb(%rip),%rdi
cmovns %r15d,%ebp
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15d,%eax
shr    $0x1f,%eax
mov    %rax,0x58(%rsp)
add    %r15d,%eax
mov    %eax,%ecx
and    $0xfe,%ecx
mov    %r15d,%edx
sub    %ecx,%edx
add    $0x30,%dl
mov    %dl,0x34(%rsp)
mov    %eax,%ecx
sar    %ecx
shr    $0x1f,%eax
add    %ecx,%eax
and    $0xfe,%eax
sub    %eax,%ecx
add    $0x30,%cl
mov    %cl,0x33(%rsp)
mov    %ebp,%eax
sar    $0x2,%eax
shr    $0x1f,%ebp
add    %eax,%ebp
and    $0xfe,%ebp
sub    %ebp,%eax
add    $0x30,%al
mov    %al,0x32(%rsp)
mov    %ebx,%eax
sar    $0x3,%eax
shr    $0x1f,%ebx
add    %eax,%ebx
and    $0xfe,%ebx
sub    %ebx,%eax
add    $0x30,%al
mov    %al,0x31(%rsp)
mov    %r13d,%eax
sar    $0x4,%eax
shr    $0x1f,%r13d
add    %eax,%r13d
and    $0xfe,%r13d
sub    %r13d,%eax
add    $0x30,%al
mov    %al,0x30(%rsp)
mov    %r12d,%eax
sar    $0x5,%eax
shr    $0x1f,%r12d
add    %eax,%r12d
and    $0xfe,%r12d
sub    %r12d,%eax
add    $0x30,%al
mov    %al,0x2f(%rsp)
mov    %r14d,%eax
sar    $0x6,%eax
shr    $0x1f,%r14d
add    %eax,%r14d
and    $0xfe,%r14d
sub    %r14d,%eax
add    $0x30,%al
mov    %al,0x2e(%rsp)
mov    0x4(%rsp),%ecx
mov    %ecx,%eax
sar    $0x7,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x2d(%rsp)
movb   $0x0,0x35(%rsp)
lea    0x2d(%rsp),%rdi
call   1030 <puts@plt>
mov    0x8(%rsp),%ebp
and    0xc(%rsp),%ebp
lea    0x7f(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
mov    %eax,0x4(%rsp)
lea    0x3f(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
mov    %eax,0x48(%rsp)
lea    0x1f(%rbp),%r12d
test   %ebp,%ebp
cmovns %ebp,%r12d
lea    0xf(%rbp),%r13d
test   %ebp,%ebp
cmovns %ebp,%r13d
lea    0x7(%rbp),%ebx
test   %ebp,%ebp
cmovns %ebp,%ebx
lea    0x3(%rbp),%r14d
test   %ebp,%ebp
lea    0xa97(%rip),%rdi
cmovns %ebp,%r14d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
mov    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%ebp
add    $0x30,%bpl
mov    %bpl,0x2b(%rsp)
mov    %eax,%ecx
sar    %ecx
shr    $0x1f,%eax
add    %ecx,%eax
and    $0xfe,%eax
sub    %eax,%ecx
add    $0x30,%cl
mov    %cl,0x2a(%rsp)
mov    %r14d,%eax
sar    $0x2,%eax
shr    $0x1f,%r14d
add    %eax,%r14d
and    $0xfe,%r14d
sub    %r14d,%eax
add    $0x30,%al
mov    %al,0x29(%rsp)
mov    %ebx,%eax
sar    $0x3,%eax
shr    $0x1f,%ebx
add    %eax,%ebx
and    $0xfe,%ebx
sub    %ebx,%eax
add    $0x30,%al
mov    %al,0x28(%rsp)
mov    %r13d,%eax
sar    $0x4,%eax
shr    $0x1f,%r13d
add    %eax,%r13d
and    $0xfe,%r13d
sub    %r13d,%eax
add    $0x30,%al
mov    %al,0x27(%rsp)
mov    %r12d,%eax
sar    $0x5,%eax
shr    $0x1f,%r12d
add    %eax,%r12d
and    $0xfe,%r12d
sub    %r12d,%eax
add    $0x30,%al
mov    %al,0x26(%rsp)
mov    0x48(%rsp),%ecx
mov    %ecx,%eax
sar    $0x6,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x25(%rsp)
mov    0x4(%rsp),%ecx
mov    %ecx,%eax
sar    $0x7,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x24(%rsp)
movb   $0x0,0x2c(%rsp)
lea    0x24(%rsp),%rdi
call   1030 <puts@plt>
mov    %r15,%rbp
mov    %r15d,%ebx
not    %ebx
lea    0x99e(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x20,%eax
nopl   0x0(%rax)
mov    %ebx,%ecx
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0x7f(%rsp,%rax,1)
mov    %ebx,%ecx
shr    %cl
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0x7e(%rsp,%rax,1)
mov    %ebx,%ecx
shr    $0x2,%cl
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0x7d(%rsp,%rax,1)
mov    %ebx,%ecx
shr    $0x3,%cl
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0x7c(%rsp,%rax,1)
shr    $0x4,%ebx
add    $0xfffffffffffffffc,%rax
jne    1690 <main+0x560>
mov    %rbp,%rbx
mov    %rbp,0x78(%rsp)
sar    $0x2,%ebx
lea    0x7f(%rbx),%eax
test   %ebx,%ebx
cmovns %ebx,%eax
mov    %eax,0x4(%rsp)
lea    0x3f(%rbx),%eax
test   %ebx,%ebx
cmovns %ebx,%eax
mov    %eax,0x48(%rsp)
lea    0x1f(%rbx),%eax
test   %ebx,%ebx
cmovns %ebx,%eax
mov    %eax,0x74(%rsp)
lea    0xf(%rbx),%eax
test   %ebx,%ebx
cmovns %ebx,%eax
mov    %eax,0x70(%rsp)
lea    0x7(%rbx),%eax
test   %ebx,%ebx
cmovns %ebx,%eax
mov    %eax,0x6c(%rsp)
lea    0x3(%rbx),%eax
test   %ebx,%ebx
movb   $0x0,0xa0(%rsp)
cmovns %ebx,%eax
mov    %eax,0x68(%rsp)
lea    0x80(%rsp),%rdi
call   1030 <puts@plt>
mov    0x8(%rsp),%ebp
xor    0xc(%rsp),%ebp
lea    0x7f(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
mov    %eax,0x64(%rsp)
lea    0x3f(%rbp),%eax
test   %ebp,%ebp
cmovns %ebp,%eax
mov    %eax,0x60(%rsp)
lea    0x1f(%rbp),%r14d
test   %ebp,%ebp
cmovns %ebp,%r14d
lea    0xf(%rbp),%r12d
test   %ebp,%ebp
cmovns %ebp,%r12d
lea    0x7(%rbp),%r13d
test   %ebp,%ebp
cmovns %ebp,%r13d
lea    0x3(%rbp),%r15d
test   %ebp,%ebp
lea    0x8a0(%rip),%rdi
cmovns %ebp,%r15d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
mov    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%ebp
add    $0x30,%bpl
mov    %bpl,0x22(%rsp)
mov    %eax,%ecx
sar    %ecx
shr    $0x1f,%eax
add    %ecx,%eax
and    $0xfe,%eax
sub    %eax,%ecx
add    $0x30,%cl
mov    %cl,0x21(%rsp)
mov    %r15d,%eax
sar    $0x2,%eax
shr    $0x1f,%r15d
add    %eax,%r15d
and    $0xfe,%r15d
sub    %r15d,%eax
add    $0x30,%al
mov    %al,0x20(%rsp)
mov    %r13d,%eax
sar    $0x3,%eax
shr    $0x1f,%r13d
add    %eax,%r13d
and    $0xfe,%r13d
sub    %r13d,%eax
add    $0x30,%al
mov    %al,0x1f(%rsp)
mov    %r12d,%eax
sar    $0x4,%eax
shr    $0x1f,%r12d
add    %eax,%r12d
and    $0xfe,%r12d
sub    %r12d,%eax
add    $0x30,%al
mov    %al,0x1e(%rsp)
mov    %r14d,%eax
sar    $0x5,%eax
shr    $0x1f,%r14d
add    %eax,%r14d
and    $0xfe,%r14d
sub    %r14d,%eax
add    $0x30,%al
mov    %al,0x1d(%rsp)
mov    0x60(%rsp),%ecx
mov    %ecx,%eax
sar    $0x6,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x1c(%rsp)
mov    0x64(%rsp),%ecx
mov    %ecx,%eax
sar    $0x7,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x1b(%rsp)
movb   $0x0,0x23(%rsp)
lea    0x7b6(%rip),%rbp
lea    0x1b(%rsp),%rdi
call   1030 <puts@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x58(%rsp),%rcx
add    %ebx,%ecx
mov    %ecx,%eax
and    $0xfe,%eax
sub    %eax,%ebx
add    $0x30,%bl
mov    %bl,0x19(%rsp)
mov    %ecx,%eax
sar    %eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x18(%rsp)
mov    0x68(%rsp),%ecx
mov    %ecx,%eax
sar    $0x2,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x17(%rsp)
mov    0x6c(%rsp),%ecx
mov    %ecx,%eax
sar    $0x3,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x16(%rsp)
mov    0x70(%rsp),%ecx
mov    %ecx,%eax
sar    $0x4,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x15(%rsp)
mov    0x74(%rsp),%ecx
mov    %ecx,%eax
sar    $0x5,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x14(%rsp)
mov    0x48(%rsp),%ecx
mov    %ecx,%eax
sar    $0x6,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x13(%rsp)
mov    0x4(%rsp),%ecx
mov    %ecx,%eax
sar    $0x7,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x12(%rsp)
movb   $0x0,0x1a(%rsp)
lea    0x12(%rsp),%rdi
call   1030 <puts@plt>
mov    0x78(%rsp),%rbp
lea    0x0(,%rbp,4),%ebx
lea    0x6b3(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x3(,%rbp,4),%eax
test   %ebx,%ebx
cmovns %ebx,%eax
lea    0x7(,%rbp,4),%edi
cmovns %ebx,%edi
lea    0xf(,%rbp,4),%esi
cmovns %ebx,%esi
lea    0x1f(,%rbp,4),%edx
cmovns %ebx,%edx
lea    0x3f(,%rbp,4),%ecx
cmovns %ebx,%ecx
lea    0x7f(,%rbp,4),%r8d
cmovns %ebx,%r8d
movw   $0x3030,0x55(%rsp)
mov    %eax,%ebp
sar    $0x2,%ebp
shr    $0x1f,%eax
add    %ebp,%eax
and    $0xfe,%eax
sub    %eax,%ebp
add    $0x30,%bpl
mov    %bpl,0x54(%rsp)
mov    %edi,%eax
sar    $0x3,%eax
shr    $0x1f,%edi
add    %eax,%edi
and    $0xfe,%edi
sub    %edi,%eax
add    $0x30,%al
mov    %al,0x53(%rsp)
mov    %esi,%eax
sar    $0x4,%eax
shr    $0x1f,%esi
add    %eax,%esi
and    $0xfe,%esi
sub    %esi,%eax
add    $0x30,%al
mov    %al,0x52(%rsp)
mov    %edx,%eax
sar    $0x5,%eax
shr    $0x1f,%edx
add    %eax,%edx
and    $0xfe,%edx
sub    %edx,%eax
add    $0x30,%al
mov    %al,0x51(%rsp)
mov    %ecx,%eax
sar    $0x6,%eax
shr    $0x1f,%ecx
add    %eax,%ecx
and    $0xfe,%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x50(%rsp)
mov    %r8d,%eax
sar    $0x7,%eax
shr    $0x1f,%r8d
add    %eax,%r8d
and    $0xfe,%r8d
sub    %r8d,%eax
add    $0x30,%al
mov    %al,0x4f(%rsp)
movb   $0x0,0x57(%rsp)
lea    0x4f(%rsp),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"a: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [4 x i8] c"b: \00"
@.str.3 = [8 x i8] c"a(2) = \00"
@.str.4 = [4 x i8] c"%s\0A\00"
@.str.5 = [8 x i8] c"b(2) = \00"
@.str.6 = [8 x i8] c"x(2) = \00"
@.str.7 = [8 x i8] c"y(2) = \00"
@.str.8 = [9 x i8] c"nx(2) = \00"
@.str.9 = [10 x i8] c"xab(2) = \00"
@.str.10 = [9 x i8] c"rx(2) = \00"
@.str.11 = [9 x i8] c"lx(2) = \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [9 x i8]
%4 = alloca i32
%5 = alloca [9 x i8]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [9 x i8]
%10 = alloca i32
%11 = alloca [9 x i8]
%12 = alloca i32
%13 = alloca i32
%14 = alloca [33 x i8]
%15 = alloca i32
%16 = alloca [9 x i8]
%17 = alloca i32
%18 = alloca [9 x i8]
%19 = alloca i32
%20 = alloca [9 x i8]
store i32 0, i32* %1
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
%22 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
%24 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
%25 = load i32, i32* %2
store i32 %25, i32* %6
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0))
store i32 7, i32* %7
br label %27
27: ; preds = %40, %0
%28 = load i32, i32* %7
%29 = icmp sge i32 %28, 0
br i1 %29, label %30, label %43
30: ; preds = %27
%31 = load i32, i32* %6
%32 = srem i32 %31, 2
%33 = add nsw i32 48, %32
%34 = trunc i32 %33 to i8
%35 = load i32, i32* %7
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [9 x i8], [9 x i8]* %3, i64 0, i64 %36
store i8 %34, i8* %37
%38 = load i32, i32* %6
%39 = sdiv i32 %38, 2
store i32 %39, i32* %6
br label %40
40: ; preds = %30
%41 = load i32, i32* %7
%42 = add nsw i32 %41, -1
store i32 %42, i32* %7
br label %27
43: ; preds = %27
%44 = getelementptr inbounds [9 x i8], [9 x i8]* %3, i64 0, i64 8
store i8 0, i8* %44
%45 = getelementptr inbounds [9 x i8], [9 x i8]* %3, i64 0, i64 0
%46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %45)
%47 = load i32, i32* %4
store i32 %47, i32* %6
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i64 0, i64 0))
store i32 7, i32* %7
br label %49
49: ; preds = %62, %43
%50 = load i32, i32* %7
%51 = icmp sge i32 %50, 0
br i1 %51, label %52, label %65
52: ; preds = %49
%53 = load i32, i32* %6
%54 = srem i32 %53, 2
%55 = add nsw i32 48, %54
%56 = trunc i32 %55 to i8
%57 = load i32, i32* %7
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [9 x i8], [9 x i8]* %5, i64 0, i64 %58
store i8 %56, i8* %59
%60 = load i32, i32* %6
%61 = sdiv i32 %60, 2
store i32 %61, i32* %6
br label %62
62: ; preds = %52
%63 = load i32, i32* %7
%64 = add nsw i32 %63, -1
store i32 %64, i32* %7
br label %49
65: ; preds = %49
%66 = getelementptr inbounds [9 x i8], [9 x i8]* %5, i64 0, i64 8
store i8 0, i8* %66
%67 = getelementptr inbounds [9 x i8], [9 x i8]* %5, i64 0, i64 0
%68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %67)
%69 = load i32, i32* %2
%70 = load i32, i32* %4
%71 = or i32 %69, %70
store i32 %71, i32* %8
%72 = load i32, i32* %8
store i32 %72, i32* %6
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0))
store i32 7, i32* %7
br label %74
74: ; preds = %87, %65
%75 = load i32, i32* %7
%76 = icmp sge i32 %75, 0
br i1 %76, label %77, label %90
77: ; preds = %74
%78 = load i32, i32* %6
%79 = srem i32 %78, 2
%80 = add nsw i32 48, %79
%81 = trunc i32 %80 to i8
%82 = load i32, i32* %7
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [9 x i8], [9 x i8]* %9, i64 0, i64 %83
store i8 %81, i8* %84
%85 = load i32, i32* %6
%86 = sdiv i32 %85, 2
store i32 %86, i32* %6
br label %87
87: ; preds = %77
%88 = load i32, i32* %7
%89 = add nsw i32 %88, -1
store i32 %89, i32* %7
br label %74
90: ; preds = %74
%91 = getelementptr inbounds [9 x i8], [9 x i8]* %9, i64 0, i64 8
store i8 0, i8* %91
%92 = getelementptr inbounds [9 x i8], [9 x i8]* %9, i64 0, i64 0
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %92)
%94 = load i32, i32* %2
%95 = load i32, i32* %4
%96 = and i32 %94, %95
store i32 %96, i32* %10
%97 = load i32, i32* %10
store i32 %97, i32* %6
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0))
store i32 7, i32* %7
br label %99
99: ; preds = %112, %90
%100 = load i32, i32* %7
%101 = icmp sge i32 %100, 0
br i1 %101, label %102, label %115
102: ; preds = %99
%103 = load i32, i32* %6
%104 = srem i32 %103, 2
%105 = add nsw i32 48, %104
%106 = trunc i32 %105 to i8
%107 = load i32, i32* %7
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [9 x i8], [9 x i8]* %11, i64 0, i64 %108
store i8 %106, i8* %109
%110 = load i32, i32* %6
%111 = sdiv i32 %110, 2
store i32 %111, i32* %6
br label %112
112: ; preds = %102
%113 = load i32, i32* %7
%114 = add nsw i32 %113, -1
store i32 %114, i32* %7
br label %99
115: ; preds = %99
%116 = getelementptr inbounds [9 x i8], [9 x i8]* %11, i64 0, i64 8
store i8 0, i8* %116
%117 = getelementptr inbounds [9 x i8], [9 x i8]* %11, i64 0, i64 0
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %117)
%119 = load i32, i32* %8
%120 = xor i32 %119, -1
store i32 %120, i32* %12
%121 = load i32, i32* %12
store i32 %121, i32* %13
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i64 0, i64 0))
store i32 31, i32* %7
br label %123
123: ; preds = %136, %115
%124 = load i32, i32* %7
%125 = icmp sge i32 %124, 0
br i1 %125, label %126, label %139
126: ; preds = %123
%127 = load i32, i32* %13
%128 = urem i32 %127, 2
%129 = add i32 48, %128
%130 = trunc i32 %129 to i8
%131 = load i32, i32* %7
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [33 x i8], [33 x i8]* %14, i64 0, i64 %132
store i8 %130, i8* %133
%134 = load i32, i32* %13
%135 = udiv i32 %134, 2
store i32 %135, i32* %13
br label %136
136: ; preds = %126
%137 = load i32, i32* %7
%138 = add nsw i32 %137, -1
store i32 %138, i32* %7
br label %123
139: ; preds = %123
%140 = getelementptr inbounds [33 x i8], [33 x i8]* %14, i64 0, i64 32
store i8 0, i8* %140
%141 = getelementptr inbounds [33 x i8], [33 x i8]* %14, i64 0, i64 0
%142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %141)
%143 = load i32, i32* %2
%144 = load i32, i32* %4
%145 = xor i32 %143, %144
store i32 %145, i32* %15
%146 = load i32, i32* %15
store i32 %146, i32* %6
%147 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0))
store i32 7, i32* %7
br label %148
148: ; preds = %161, %139
%149 = load i32, i32* %7
%150 = icmp sge i32 %149, 0
br i1 %150, label %151, label %164
151: ; preds = %148
%152 = load i32, i32* %6
%153 = srem i32 %152, 2
%154 = add nsw i32 48, %153
%155 = trunc i32 %154 to i8
%156 = load i32, i32* %7
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [9 x i8], [9 x i8]* %16, i64 0, i64 %157
store i8 %155, i8* %158
%159 = load i32, i32* %6
%160 = sdiv i32 %159, 2
store i32 %160, i32* %6
br label %161
161: ; preds = %151
%162 = load i32, i32* %7
%163 = add nsw i32 %162, -1
store i32 %163, i32* %7
br label %148
164: ; preds = %148
%165 = getelementptr inbounds [9 x i8], [9 x i8]* %16, i64 0, i64 8
store i8 0, i8* %165
%166 = getelementptr inbounds [9 x i8], [9 x i8]* %16, i64 0, i64 0
%167 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %166)
%168 = load i32, i32* %8
%169 = ashr i32 %168, 2
store i32 %169, i32* %17
%170 = load i32, i32* %17
store i32 %170, i32* %6
%171 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i64 0, i64 0))
store i32 7, i32* %7
br label %172
172: ; preds = %185, %164
%173 = load i32, i32* %7
%174 = icmp sge i32 %173, 0
br i1 %174, label %175, label %188
175: ; preds = %172
%176 = load i32, i32* %6
%177 = srem i32 %176, 2
%178 = add nsw i32 48, %177
%179 = trunc i32 %178 to i8
%180 = load i32, i32* %7
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [9 x i8], [9 x i8]* %18, i64 0, i64 %181
store i8 %179, i8* %182
%183 = load i32, i32* %6
%184 = sdiv i32 %183, 2
store i32 %184, i32* %6
br label %185
185: ; preds = %175
%186 = load i32, i32* %7
%187 = add nsw i32 %186, -1
store i32 %187, i32* %7
br label %172
188: ; preds = %172
%189 = getelementptr inbounds [9 x i8], [9 x i8]* %18, i64 0, i64 8
store i8 0, i8* %189
%190 = getelementptr inbounds [9 x i8], [9 x i8]* %18, i64 0, i64 0
%191 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %190)
%192 = load i32, i32* %8
%193 = shl i32 %192, 2
store i32 %193, i32* %19
%194 = load i32, i32* %19
store i32 %194, i32* %6
%195 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.11, i64 0, i64 0))
store i32 7, i32* %7
br label %196
196: ; preds = %209, %188
%197 = load i32, i32* %7
%198 = icmp sge i32 %197, 0
br i1 %198, label %199, label %212
199: ; preds = %196
%200 = load i32, i32* %6
%201 = srem i32 %200, 2
%202 = add nsw i32 48, %201
%203 = trunc i32 %202 to i8
%204 = load i32, i32* %7
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [9 x i8], [9 x i8]* %20, i64 0, i64 %205
store i8 %203, i8* %206
%207 = load i32, i32* %6
%208 = sdiv i32 %207, 2
store i32 %208, i32* %6
br label %209
209: ; preds = %199
%210 = load i32, i32* %7
%211 = add nsw i32 %210, -1
store i32 %211, i32* %7
br label %196
212: ; preds = %196
%213 = getelementptr inbounds [9 x i8], [9 x i8]* %20, i64 0, i64 8
store i8 0, i8* %213
%214 = getelementptr inbounds [9 x i8], [9 x i8]* %20, i64 0, i64 0
%215 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i8* %214)
ret i32 0
}

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