#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 */
unsigned long long getL();
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, char **argv) {
  unsigned long long UL = getL();
  long long L = (long long)UL;
  unsigned int ui = (unsigned int)UL;
  int i = (int)UL;
  unsigned short us = (unsigned short)UL;
  short s = (short)UL;
  unsigned char ub = (unsigned char)UL;
  signed char b = (signed char)UL;
  printf("   ui = %u (0x%x)\t\tUL-ui = %lld (0x%llx)\n", ui, ui, UL - ui,
         UL - ui);
  printf("ui*ui = %u (0x%x)\t  UL/ui = %lld (0x%llx)\n\n",
         (unsigned int)ui * ui, (unsigned int)ui * ui, UL / ui, UL / ui);
  printf("    i = %d (0x%x)\tL-i = %lld (0x%llx)\n", i, i, L - i, L - i);
  printf(" i* i = %d (0x%x)\tL/ i = %lld (0x%llx)\n\n", (int)i * i, (int)i * i,
         L / i, L / i);
  printf("us    = %u (0x%x)\t\tUL-us = %lld (0x%llx)\n", us, us, UL - us,
         UL - us);
  printf("us*us = %u (0x%x)\t  UL/us = %lld (0x%llx)\n\n",
         (unsigned short)us * us, (unsigned short)us * us, UL / us, UL / us);
  printf(" s    = %d (0x%x)\tL-s = %lld (0x%llx)\n", s, s, L - s, L - s);
  printf(" s* s = %d (0x%x)\tL/ s = %lld (0x%llx)\n\n", (short)s * s,
         (short)s * s, L / s, L / s);
  printf("ub    = %u (0x%x)\t\tUL-ub = %lld (0x%llx)\n", ub, ub, UL - ub,
         UL - ub);
  printf("ub*ub = %u (0x%x)\t\tUL/ub = %lld (0x%llx)\n\n",
         (unsigned char)ub * ub, (unsigned char)ub * ub, UL / ub, UL / ub);
  printf(" b    = %d (0x%x)\t\tL-b = %lld (0x%llx)\n", b, b, L - b, L - b);
  printf(" b* b = %d (0x%x)\t\t\tL/b = %lld (0x%llx)\n\n", (signed char)b * b,
         (signed char)b * b, L / b, L / b);
  unsigned int uiprod =
      (ui + 1u) * (ui + 1u) - (unsigned int)(ui << 2) - (unsigned int)1u;
  unsigned short usprod =
      (us + 1u) * (us + 1u) - (unsigned short)(us << 2) - (unsigned short)1u;
  unsigned char ubprod =
      (ub + 1u) * (ub + 1u) - (unsigned char)(ub << 2) - (unsigned char)1u;
  int iprod = (i + 1) * (i + 1) - (int)(i << 2) - (int)1;
  short sprod = (s + 1) * (s + 1) - (short)(s << 2) - (short)1;
  signed char bprod = (b + 1) * (b + 1) - (char)(b << 2) - (char)1;
  unsigned int uidiv = (unsigned int)(UL / ui) * (unsigned int)(UL / ui);
  unsigned short usdiv = (unsigned short)(UL / us) * (unsigned short)(UL / us);
  unsigned char ubdiv = (unsigned char)(UL / ub) * (unsigned char)(UL / ub);
  int idiv = (int)(L / i) * (int)(L / i);
  short sdiv = (short)(L / s) * (short)(L / s);
  signed char bdiv = (signed char)(L / b) * (signed char)(L / b);
  printf("\n");
  printf("uiprod = %u (0x%x)\t  uidiv = %u (0x%x)\n\n", uiprod, uiprod, uidiv,
         uidiv);
  printf("usprod = %u (0x%x)\t  usdiv = %u (0x%x)\n\n", usprod, usprod, usdiv,
         usdiv);
  printf("ubprod = %u (0x%x)\t  ubdiv = %u (0x%x)\n\n", ubprod, ubprod, ubdiv,
         ubdiv);
  printf(" iprod = %u (0x%x)\t   idiv = %u (0x%x)\n\n", iprod, iprod, idiv,
         idiv);
  printf(" sprod = %u (0x%x)\t   sdiv = %u (0x%x)\n\n", sprod, sprod, sdiv,
         sdiv);
  printf(" bprod = %u (0x%x)\t   bdiv = %u (0x%x)\n\n", bprod, bprod, bdiv,
         bdiv);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x0,%al
call   1030 <getL@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %ax,-0x2a(%rbp)
mov    -0x18(%rbp),%rax
mov    %ax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    %al,-0x2d(%rbp)
mov    -0x18(%rbp),%rax
mov    %al,-0x2e(%rbp)
mov    -0x24(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%eax
sub    %rax,%rcx
mov    -0x18(%rbp),%r8
mov    -0x24(%rbp),%eax
sub    %rax,%r8
lea    0xe67(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x24(%rbp),%esi
imul   -0x24(%rbp),%esi
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%edx
mov    %edx,%edi
xor    %edx,%edx
div    %rdi
mov    -0x80(%rbp),%edx
mov    %rax,%r8
lea    0xe4f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x20(%rbp),%rcx
movslq -0x28(%rbp),%rax
sub    %rax,%rcx
mov    -0x20(%rbp),%r8
movslq -0x28(%rbp),%rax
sub    %rax,%r8
lea    0xe51(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%esi
imul   -0x28(%rbp),%esi
mov    -0x28(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rdi
cqto
idiv   %rdi
mov    -0x7c(%rbp),%edx
mov    %rax,%r8
lea    0xe36(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movzwl -0x2a(%rbp),%esi
movzwl -0x2a(%rbp),%edx
mov    -0x18(%rbp),%rcx
movzwl -0x2a(%rbp),%eax
sub    %rax,%rcx
mov    -0x18(%rbp),%r8
movzwl -0x2a(%rbp),%eax
sub    %rax,%r8
lea    0xe33(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movzwl -0x2a(%rbp),%esi
movzwl -0x2a(%rbp),%eax
imul   %eax,%esi
movzwl -0x2a(%rbp),%eax
movzwl -0x2a(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movzwl -0x2a(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
movzwl -0x2a(%rbp),%edx
mov    %edx,%edi
xor    %edx,%edx
div    %rdi
mov    -0x78(%rbp),%edx
mov    %rax,%r8
lea    0xe11(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movswl -0x2c(%rbp),%esi
movswl -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rcx
movswq -0x2c(%rbp),%rax
sub    %rax,%rcx
mov    -0x20(%rbp),%r8
movswq -0x2c(%rbp),%rax
sub    %rax,%r8
lea    0xe0f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movswl -0x2c(%rbp),%esi
movswl -0x2c(%rbp),%eax
imul   %eax,%esi
movswl -0x2c(%rbp),%eax
movswl -0x2c(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x20(%rbp),%rax
movswq -0x2c(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
movswq -0x2c(%rbp),%rdi
cqto
idiv   %rdi
mov    -0x74(%rbp),%edx
mov    %rax,%r8
lea    0xdea(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movzbl -0x2d(%rbp),%esi
movzbl -0x2d(%rbp),%edx
mov    -0x18(%rbp),%rcx
movzbl -0x2d(%rbp),%eax
sub    %rax,%rcx
mov    -0x18(%rbp),%r8
movzbl -0x2d(%rbp),%eax
sub    %rax,%r8
lea    0xde7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movzbl -0x2d(%rbp),%esi
movzbl -0x2d(%rbp),%eax
imul   %eax,%esi
movzbl -0x2d(%rbp),%eax
movzbl -0x2d(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movzbl -0x2d(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
movzbl -0x2d(%rbp),%edx
mov    %edx,%edi
xor    %edx,%edx
div    %rdi
mov    -0x70(%rbp),%edx
mov    %rax,%r8
lea    0xdc5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsbl -0x2e(%rbp),%esi
movsbl -0x2e(%rbp),%edx
mov    -0x20(%rbp),%rcx
movsbq -0x2e(%rbp),%rax
sub    %rax,%rcx
mov    -0x20(%rbp),%r8
movsbq -0x2e(%rbp),%rax
sub    %rax,%r8
lea    0xdc2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsbl -0x2e(%rbp),%esi
movsbl -0x2e(%rbp),%eax
imul   %eax,%esi
movsbl -0x2e(%rbp),%eax
movsbl -0x2e(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x20(%rbp),%rax
movsbq -0x2e(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
movsbq -0x2e(%rbp),%rdi
cqto
idiv   %rdi
mov    -0x6c(%rbp),%edx
mov    %rax,%r8
lea    0xd9e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
movzwl -0x2a(%rbp),%eax
add    $0x1,%eax
movzwl -0x2a(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
movzwl -0x2a(%rbp),%ecx
shl    $0x2,%ecx
movzwl %cx,%ecx
sub    %ecx,%eax
sub    $0x1,%eax
mov    %ax,-0x36(%rbp)
movzbl -0x2d(%rbp),%eax
add    $0x1,%eax
movzbl -0x2d(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
movzbl -0x2d(%rbp),%ecx
shl    $0x2,%ecx
movzbl %cl,%ecx
sub    %ecx,%eax
sub    $0x1,%eax
mov    %al,-0x37(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    -0x28(%rbp),%ecx
shl    $0x2,%ecx
sub    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movswl -0x2c(%rbp),%eax
add    $0x1,%eax
movswl -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
movswl -0x2c(%rbp),%ecx
shl    $0x2,%ecx
movswl %cx,%ecx
sub    %ecx,%eax
sub    $0x1,%eax
mov    %ax,-0x3e(%rbp)
movsbl -0x2e(%rbp),%eax
add    $0x1,%eax
movsbl -0x2e(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
movsbl -0x2e(%rbp),%ecx
shl    $0x2,%ecx
movsbl %cl,%ecx
sub    %ecx,%eax
sub    $0x1,%eax
mov    %al,-0x3f(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x68(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movzwl -0x2a(%rbp),%ecx
xor    %edx,%edx
div    %rcx
movzwl %ax,%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rax
movzwl -0x2a(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x64(%rbp),%eax
movzwl %cx,%ecx
imul   %ecx,%eax
mov    %ax,-0x46(%rbp)
mov    -0x18(%rbp),%rax
movzbl -0x2d(%rbp),%ecx
xor    %edx,%edx
div    %rcx
movzbl %al,%eax
mov    %eax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movzbl -0x2d(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x60(%rbp),%eax
movzbl %cl,%ecx
imul   %ecx,%eax
mov    %al,-0x47(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
cqto
idiv   %rcx
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x5c(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movswq -0x2c(%rbp),%rcx
cqto
idiv   %rcx
cwtl
mov    %eax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movswq -0x2c(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x58(%rbp),%eax
movswl %cx,%ecx
imul   %ecx,%eax
mov    %ax,-0x4e(%rbp)
mov    -0x20(%rbp),%rax
movsbq -0x2e(%rbp),%rcx
cqto
idiv   %rcx
movsbl %al,%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movsbq -0x2e(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x54(%rbp),%eax
movsbl %cl,%ecx
imul   %ecx,%eax
mov    %al,-0x4f(%rbp)
lea    0xcd6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    -0x44(%rbp),%ecx
mov    -0x44(%rbp),%r8d
lea    0xbc7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movzwl -0x36(%rbp),%esi
movzwl -0x36(%rbp),%edx
movzwl -0x46(%rbp),%ecx
movzwl -0x46(%rbp),%r8d
lea    0xbd1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movzbl -0x37(%rbp),%esi
movzbl -0x37(%rbp),%edx
movzbl -0x47(%rbp),%ecx
movzbl -0x47(%rbp),%r8d
lea    0xbdb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x3c(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x4c(%rbp),%ecx
mov    -0x4c(%rbp),%r8d
lea    0xbe9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movswl -0x3e(%rbp),%esi
movswl -0x3e(%rbp),%edx
movswl -0x4e(%rbp),%ecx
movswl -0x4e(%rbp),%r8d
lea    0xbf3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsbl -0x3f(%rbp),%esi
movsbl -0x3f(%rbp),%edx
movsbl -0x4f(%rbp),%ecx
movsbl -0x4f(%rbp),%r8d
lea    0xbfd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
xor    %eax,%eax
call   1040 <getL@plt>
mov    %rax,%rbx
lea    0xeb1(%rip),%rdi
movabs $0xffffffff00000000,%rbp
ff ff ff
mov    %rax,%rcx
and    %rbp,%rcx
mov    %ebx,%esi
mov    %ebx,%edx
mov    %rcx,%r8
xor    %eax,%eax
call   1050 <printf@plt>
mov    %ebx,%r14d
imul   %ebx,%r14d
mov    %ebx,%ecx
and    %rbx,%rbp
je     1185 <main+0x55>
mov    %rbx,%rax
xor    %edx,%edx
div    %rcx
jmp    118b <main+0x5b>
mov    %ebx,%eax
xor    %edx,%edx
div    %ecx
lea    0xe98(%rip),%rdi
mov    %r14d,%esi
mov    %r14d,%edx
mov    %rax,%rcx
mov    %rax,0x40(%rsp)
mov    %rax,%r8
xor    %eax,%eax
call   1050 <printf@plt>
movslq %ebx,%rbp
mov    %rbx,%rcx
sub    %rbp,%rcx
lea    0xe9c(%rip),%rdi
mov    %ebx,%esi
mov    %ebx,%edx
mov    %rcx,%r8
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbx,%rax
or     %rbp,%rax
shr    $0x20,%rax
je     11de <main+0xae>
mov    %rbx,%rax
cqto
idiv   %rbp
jmp    11e4 <main+0xb4>
mov    %ebx,%eax
xor    %edx,%edx
div    %ebx
lea    0xe92(%rip),%rdi
mov    %r14d,%esi
mov    %r14d,%edx
mov    %rax,%rcx
mov    %rax,0x38(%rsp)
mov    %rax,%r8
xor    %eax,%eax
call   1050 <printf@plt>
movzwl %bx,%r12d
movzwl %bx,%ebp
mov    %rbx,%rcx
and    $0xffffffffffff0000,%rcx
lea    0xe8b(%rip),%rdi
mov    %r12d,%esi
mov    %r12d,%edx
mov    %rcx,%r8
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r12d,%esi
imul   %r12d,%esi
mov    %rbx,%r14
shr    $0x20,%r14
je     1245 <main+0x115>
mov    %rbx,%rax
xor    %edx,%edx
div    %rbp
jmp    124b <main+0x11b>
mov    %ebx,%eax
xor    %edx,%edx
div    %ebp
lea    0xe7e(%rip),%rdi
mov    %esi,%edx
mov    %rax,%rcx
mov    %rax,0x30(%rsp)
mov    %rax,%r8
xor    %eax,%eax
call   1050 <printf@plt>
movswl %bx,%ebp
movswq %bx,%r15
mov    %rbx,%rcx
sub    %r15,%rcx
lea    0xe82(%rip),%rdi
mov    %ebp,%esi
mov    %ebp,%edx
mov    %rcx,%r8
xor    %eax,%eax
call   1050 <printf@plt>
mov    %rbp,0x8(%rsp)
mov    %ebp,%esi
imul   %ebp,%esi
mov    %rbx,%rax
or     %r15,%rax
shr    $0x20,%rax
je     12a8 <main+0x178>
mov    %rbx,%rax
cqto
idiv   %r15
jmp    12af <main+0x17f>
mov    %ebx,%eax
xor    %edx,%edx
div    %r15d
lea    0xe6d(%rip),%rdi
mov    %esi,%edx
mov    %rax,%rcx
mov    %rax,0x28(%rsp)
mov    %rax,%r8
xor    %eax,%eax
call   1050 <printf@plt>
movzbl %bl,%r15d
movzbl %bl,%ebp
mov    %rbx,%rcx
and    $0xffffffffffffff00,%rcx
lea    0xe6a(%rip),%rdi
mov    %r15d,%esi
mov    %r15d,%edx
mov    %rcx,%r8
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r15d,%esi
imul   %r15d,%esi
test   %r14,%r14
je     1308 <main+0x1d8>
mov    %rbx,%rax
xor    %edx,%edx
div    %rbp
jmp    130e <main+0x1de>
mov    %ebx,%eax
xor    %edx,%edx
div    %ebp
lea    0xe61(%rip),%rdi
mov    %esi,%edx
mov    %rax,%rcx
mov    %rax,0x20(%rsp)
mov    %rax,%r8
xor    %eax,%eax
call   1050 <printf@plt>
movsbl %bl,%r14d
movsbq %bl,%rbp
mov    %rbx,%rcx
sub    %rbp,%rcx
lea    0xe63(%rip),%rdi
mov    %r14d,%esi
mov    %r14d,%edx
mov    %rcx,%r8
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r14d,%esi
imul   %r14d,%esi
mov    %rbx,%rax
or     %rbp,%rax
shr    $0x20,%rax
je     136b <main+0x23b>
mov    %rbx,%rax
cqto
idiv   %rbp
jmp    1371 <main+0x241>
mov    %ebx,%eax
xor    %edx,%edx
div    %ebp
mov    %rax,0x18(%rsp)
lea    0xe4c(%rip),%rdi
mov    %esi,%edx
mov    %rax,%rcx
mov    %rax,%r8
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1(%rbx),%r13d
imul   %r13d,%r13d
lea    0x0(,%rbx,4),%eax
not    %eax
add    %eax,%r13d
add    $0x1,%r12d
imul   %r12d,%r12d
add    %eax,%r12d
mov    %r12d,0x10(%rsp)
add    $0x1,%r15d
imul   %r15d,%r15d
add    %eax,%r15d
mov    %r15d,0x14(%rsp)
mov    0x8(%rsp),%r15
lea    0x1(%r15),%eax
imul   %eax,%eax
shl    $0x2,%r15d
not    %r15d
add    %eax,%r15d
lea    0x1(%r14),%eax
imul   %eax,%eax
shl    $0x2,%r14b
not    %r14b
add    %r14b,%al
mov    %eax,0x8(%rsp)
mov    0x40(%rsp),%rbp
imul   %ebp,%ebp
mov    0x30(%rsp),%rbx
imul   %ebx,%ebx
mov    0x20(%rsp),%r12
imul   %r12d,%r12d
mov    0x38(%rsp),%r14
imul   %r14d,%r14d
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xdd5(%rip),%rdi
mov    %r13d,%esi
mov    %r13d,%edx
mov    %ebp,%ecx
mov    %ebp,%r8d
xor    %eax,%eax
call   1050 <printf@plt>
movzwl 0x10(%rsp),%edx
movzwl %bx,%ecx
lea    0xddd(%rip),%rdi
mov    %edx,%esi
mov    %ecx,%r8d
xor    %eax,%eax
call   1050 <printf@plt>
movzbl 0x14(%rsp),%edx
movzbl %r12b,%ecx
lea    0xdea(%rip),%rdi
mov    %edx,%esi
mov    %ecx,%r8d
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xe00(%rip),%rdi
mov    %r13d,%esi
mov    %r13d,%edx
mov    %r14d,%ecx
mov    %r14d,%r8d
xor    %eax,%eax
call   1050 <printf@plt>
movswl %r15w,%edx
mov    0x28(%rsp),%rax
imul   %eax,%eax
movswl %ax,%ecx
lea    0xe00(%rip),%rdi
mov    %edx,%esi
mov    %ecx,%r8d
xor    %eax,%eax
call   1050 <printf@plt>
movsbl 0x8(%rsp),%edx
mov    0x18(%rsp),%rax
imul   %eax,%eax
movsbl %al,%ecx
lea    0xe06(%rip),%rdi
mov    %edx,%esi
mov    %ecx,%r8d
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [42 x i8] c" ui = %u (0x%x)\09\09UL-ui = %lld (0x%llx)\0A\00"
@.str.1 = [44 x i8] c"ui*ui = %u (0x%x)\09 UL/ui = %lld (0x%llx)\0A\0A\00"
@.str.2 = [39 x i8] c" i = %d (0x%x)\09L-i = %lld (0x%llx)\0A\00"
@.str.3 = [41 x i8] c" i* i = %d (0x%x)\09L/ i = %lld (0x%llx)\0A\0A\00"
@.str.4 = [42 x i8] c"us = %u (0x%x)\09\09UL-us = %lld (0x%llx)\0A\00"
@.str.5 = [44 x i8] c"us*us = %u (0x%x)\09 UL/us = %lld (0x%llx)\0A\0A\00"
@.str.6 = [39 x i8] c" s = %d (0x%x)\09L-s = %lld (0x%llx)\0A\00"
@.str.7 = [41 x i8] c" s* s = %d (0x%x)\09L/ s = %lld (0x%llx)\0A\0A\00"
@.str.8 = [42 x i8] c"ub = %u (0x%x)\09\09UL-ub = %lld (0x%llx)\0A\00"
@.str.9 = [43 x i8] c"ub*ub = %u (0x%x)\09\09UL/ub = %lld (0x%llx)\0A\0A\00"
@.str.10 = [40 x i8] c" b = %d (0x%x)\09\09L-b = %lld (0x%llx)\0A\00"
@.str.11 = [42 x i8] c" b* b = %d (0x%x)\09\09\09L/b = %lld (0x%llx)\0A\0A\00"
@.str.13 = [41 x i8] c"uiprod = %u (0x%x)\09 uidiv = %u (0x%x)\0A\0A\00"
@.str.14 = [41 x i8] c"usprod = %u (0x%x)\09 usdiv = %u (0x%x)\0A\0A\00"
@.str.15 = [41 x i8] c"ubprod = %u (0x%x)\09 ubdiv = %u (0x%x)\0A\0A\00"
@.str.16 = [41 x i8] c" iprod = %u (0x%x)\09 idiv = %u (0x%x)\0A\0A\00"
@.str.17 = [41 x i8] c" sprod = %u (0x%x)\09 sdiv = %u (0x%x)\0A\0A\00"
@.str.18 = [41 x i8] c" bprod = %u (0x%x)\09 bdiv = %u (0x%x)\0A\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i64 (...) @getL()
%4 = trunc i64 %3 to i32
%5 = trunc i64 %3 to i16
%6 = trunc i64 %3 to i8
%7 = and i64 %3, 4294967295
%8 = and i64 %3, -4294967296
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0), i32 %4, i32 %4, i64 %8, i64 %8)
%10 = mul i32 %4, %4
%11 = udiv i64 %3, %7
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.1, i64 0, i64 0), i32 %10, i32 %10, i64 %11, i64 %11)
%13 = shl i64 %3, 32
%14 = ashr exact i64 %13, 32
%15 = sub nsw i64 %3, %14
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.2, i64 0, i64 0), i32 %4, i32 %4, i64 %15, i64 %15)
%17 = sdiv i64 %3, %14
%18 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.3, i64 0, i64 0), i32 %10, i32 %10, i64 %17, i64 %17)
%19 = and i32 %4, 65535
%20 = and i64 %3, 65535
%21 = and i64 %3, -65536
%22 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.4, i64 0, i64 0), i32 %19, i32 %19, i64 %21, i64 %21)
%23 = mul nuw nsw i32 %19, %19
%24 = udiv i64 %3, %20
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.5, i64 0, i64 0), i32 %23, i32 %23, i64 %24, i64 %24)
%26 = sext i16 %5 to i32
%27 = shl i64 %3, 48
%28 = ashr exact i64 %27, 48
%29 = sub nsw i64 %3, %28
%30 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.6, i64 0, i64 0), i32 %26, i32 %26, i64 %29, i64 %29)
%31 = mul nsw i32 %26, %26
%32 = sdiv i64 %3, %28
%33 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.7, i64 0, i64 0), i32 %31, i32 %31, i64 %32, i64 %32)
%34 = and i32 %4, 255
%35 = and i64 %3, 255
%36 = and i64 %3, -256
%37 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.8, i64 0, i64 0), i32 %34, i32 %34, i64 %36, i64 %36)
%38 = mul nuw nsw i32 %34, %34
%39 = udiv i64 %3, %35
%40 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.9, i64 0, i64 0), i32 %38, i32 %38, i64 %39, i64 %39)
%41 = sext i8 %6 to i32
%42 = shl i64 %3, 56
%43 = ashr exact i64 %42, 56
%44 = sub nsw i64 %3, %43
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.10, i64 0, i64 0), i32 %41, i32 %41, i64 %44, i64 %44)
%46 = mul nsw i32 %41, %41
%47 = sdiv i64 %3, %43
%48 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.11, i64 0, i64 0), i32 %46, i32 %46, i64 %47, i64 %47)
%49 = add i32 %4, 1
%50 = mul i32 %49, %49
%51 = mul i32 %4, -4
%52 = add i32 %51, -1
%53 = add i32 %52, %50
%54 = add nuw nsw i32 %19, 1
%55 = mul i32 %54, %54
%56 = shl i32 %4, 2
%57 = xor i32 %56, -1
%58 = add i32 %55, %57
%59 = add nuw nsw i32 %34, 1
%60 = mul nuw nsw i32 %59, %59
%61 = add i32 %60, %57
%62 = add nsw i32 %26, 1
%63 = mul nsw i32 %62, %62
%64 = shl i16 %5, 2
%65 = xor i16 %64, -1
%66 = trunc i32 %63 to i16
%67 = add i16 %66, %65
%68 = add nsw i32 %41, 1
%69 = mul nsw i32 %68, %68
%70 = shl i8 %6, 2
%71 = xor i8 %70, -1
%72 = trunc i32 %69 to i8
%73 = add i8 %72, %71
%74 = trunc i64 %11 to i32
%75 = mul i32 %74, %74
%76 = trunc i64 %24 to i32
%77 = and i32 %76, 65535
%78 = mul nuw nsw i32 %77, %77
%79 = trunc i64 %39 to i32
%80 = and i32 %79, 255
%81 = mul nuw nsw i32 %80, %80
%82 = trunc i64 %17 to i32
%83 = mul nsw i32 %82, %82
%84 = trunc i64 %32 to i32
%85 = shl i32 %84, 16
%86 = ashr exact i32 %85, 16
%87 = trunc i64 %47 to i32
%88 = shl i32 %87, 24
%89 = ashr exact i32 %88, 24
%90 = tail call i32 @putchar(i32 10)
%91 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.13, i64 0, i64 0), i32 %53, i32 %53, i32 %75, i32 %75)
%92 = and i32 %58, 65535
%93 = and i32 %78, 65535
%94 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.14, i64 0, i64 0), i32 %92, i32 %92, i32 %93, i32 %93)
%95 = and i32 %61, 255
%96 = and i32 %81, 255
%97 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.15, i64 0, i64 0), i32 %95, i32 %95, i32 %96, i32 %96)
%98 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.16, i64 0, i64 0), i32 %53, i32 %53, i32 %83, i32 %83)
%99 = sext i16 %67 to i32
%100 = mul i32 %85, %86
%101 = ashr exact i32 %100, 16
%102 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.17, i64 0, i64 0), i32 %99, i32 %99, i32 %101, i32 %101)
%103 = sext i8 %73 to i32
%104 = mul i32 %88, %89
%105 = ashr exact i32 %104, 24
%106 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.18, i64 0, i64 0), i32 %103, i32 %103, i32 %105, i32 %105)
ret i32 0
}