#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 EXIT_SUCCESS;
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  unsigned char num_a = 31;
  unsigned char num_b = 10;
  unsigned char num_c = 73;
  unsigned char res_not_a = ~num_a;
  unsigned char res_not_b = ~num_b;
  unsigned char res_not_c = ~num_c;
  unsigned char res_and_1 = num_a & num_b;
  unsigned char res_and_2 = num_b & num_c;
  unsigned char res_and_3 = num_c & num_a;
  unsigned char res_or_1 = num_a | num_b;
  unsigned char res_or_2 = num_b | num_c;
  unsigned char res_or_3 = num_c | num_a;
  unsigned char res_xor_1 = num_a ^ num_b;
  unsigned char res_xor_2 = num_b ^ num_c;
  unsigned char res_xor_3 = num_c ^ num_a;
  unsigned char res_lf_1 = num_a << 1;
  unsigned char res_lf_2 = num_b << 2;
  unsigned char res_lf_3 = num_c << 3;
  unsigned int res_lf_4 = num_c << 3;
  unsigned char res_rt_1 = num_a >> 1;
  unsigned char res_rt_2 = num_b >> 2;
  unsigned char res_rt_3 = num_c >> 3;
  printf("I'm working on unsigned char (1 byte: 8 bit)\n\n");
  printf("One's complement operator ( ~ )\n");
  printf(" ~%d = %3d (hex: %#x)\n", num_a, res_not_a, res_not_a);
  printf(" ~%d = %3d (hex: %#x)\n", num_b, res_not_b, res_not_b);
  printf(" ~%d = %3d (hex: %#x)\n", num_c, res_not_c, res_not_c);
  printf("\nBitwise AND ( & )\n");
  printf("%3d & %3d = %3d (hex: %#x)\n", num_a, num_b, res_and_1, res_and_1);
  printf("%3d & %3d = %3d (hex: %#x)\n", num_b, num_c, res_and_2, res_and_2);
  printf("%3d & %3d = %3d (hex: %#x)\n", num_c, num_a, res_and_3, res_and_3);
  printf("\nBitwise inclusvie OR ( | )\n");
  printf("%3d | %3d = %3d (hex: %#x)\n", num_a, num_b, res_or_1, res_or_1);
  printf("%3d | %3d = %3d (hex: %#x)\n", num_b, num_c, res_or_2, res_or_2);
  printf("%3d | %3d = %3d (hex: %#x)\n", num_c, num_a, res_or_3, res_or_3);
  printf("\nBitwise exclusvie OR, or XOR ( ^ )\n");
  printf("%3d ^ %3d = %3d (hex: %#x)\n", num_a, num_b, res_xor_1, res_xor_1);
  printf("%3d ^ %3d = %3d (hex: %#x)\n", num_b, num_c, res_xor_2, res_xor_2);
  printf("%3d ^ %3d = %3d (hex: %#x)\n", num_c, num_a, res_xor_3, res_xor_3);
  printf("\nLeft shift operator ( << )\n");
  printf("%3d <<%3d = %3d (hex: %#x)\n", num_a, 1, res_lf_1, res_lf_1);
  printf("%3d <<%3d = %3d (hex: %#x)\n", num_b, 2, res_lf_2, res_lf_2);
  printf("%3d <<%3d = %3d (hex: %#x)\n", num_c, 3, res_lf_3, res_lf_3);
  printf("%3d <<%3d = %3d (hex: %#x) - unsigned int (4 byte: 32 bit)\n", num_c,
         3, res_lf_4, res_lf_4);
  printf("\nRight shift operator ( >> )\n");
  printf("%3d <<%3d = %3d (hex: %#x)\n", num_a, 1, res_rt_1, res_rt_1);
  printf("%3d <<%3d = %3d (hex: %#x)\n", num_b, 2, res_rt_2, res_rt_2);
  printf("%3d <<%3d = %3d (hex: %#x)\n", num_c, 3, res_rt_3, res_rt_3);
  return (EXIT_SUCCESS);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
movb   $0x1f,-0x5(%rbp)
movb   $0xa,-0x6(%rbp)
movb   $0x49,-0x7(%rbp)
movzbl -0x5(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0x8(%rbp)
movzbl -0x6(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0x9(%rbp)
movzbl -0x7(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xa(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
mov    %al,-0xb(%rbp)
movzbl -0x6(%rbp),%eax
movzbl -0x7(%rbp),%ecx
and    %ecx,%eax
mov    %al,-0xc(%rbp)
movzbl -0x7(%rbp),%eax
movzbl -0x5(%rbp),%ecx
and    %ecx,%eax
mov    %al,-0xd(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0xe(%rbp)
movzbl -0x6(%rbp),%eax
movzbl -0x7(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0xf(%rbp)
movzbl -0x7(%rbp),%eax
movzbl -0x5(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0x10(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x11(%rbp)
movzbl -0x6(%rbp),%eax
movzbl -0x7(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x12(%rbp)
movzbl -0x7(%rbp),%eax
movzbl -0x5(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x13(%rbp)
movzbl -0x5(%rbp),%eax
shl    $0x1,%eax
mov    %al,-0x14(%rbp)
movzbl -0x6(%rbp),%eax
shl    $0x2,%eax
mov    %al,-0x15(%rbp)
movzbl -0x7(%rbp),%eax
shl    $0x3,%eax
mov    %al,-0x16(%rbp)
movzbl -0x7(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x1c(%rbp)
movzbl -0x5(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x1d(%rbp)
movzbl -0x6(%rbp),%eax
sar    $0x2,%eax
mov    %al,-0x1e(%rbp)
movzbl -0x7(%rbp),%eax
sar    $0x3,%eax
mov    %al,-0x1f(%rbp)
lea    0xdf5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xe16(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x5(%rbp),%esi
movzbl -0x8(%rbp),%edx
movzbl -0x8(%rbp),%ecx
lea    0xe1d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x6(%rbp),%esi
movzbl -0x9(%rbp),%edx
movzbl -0x9(%rbp),%ecx
lea    0xe03(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x7(%rbp),%esi
movzbl -0xa(%rbp),%edx
movzbl -0xa(%rbp),%ecx
lea    0xde9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdf2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x5(%rbp),%esi
movzbl -0x6(%rbp),%edx
movzbl -0xb(%rbp),%ecx
movzbl -0xb(%rbp),%r8d
lea    0xde7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x6(%rbp),%esi
movzbl -0x7(%rbp),%edx
movzbl -0xc(%rbp),%ecx
movzbl -0xc(%rbp),%r8d
lea    0xdc8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x7(%rbp),%esi
movzbl -0x5(%rbp),%edx
movzbl -0xd(%rbp),%ecx
movzbl -0xd(%rbp),%r8d
lea    0xda9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdb7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x5(%rbp),%esi
movzbl -0x6(%rbp),%edx
movzbl -0xe(%rbp),%ecx
movzbl -0xe(%rbp),%r8d
lea    0xdb5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x6(%rbp),%esi
movzbl -0x7(%rbp),%edx
movzbl -0xf(%rbp),%ecx
movzbl -0xf(%rbp),%r8d
lea    0xd96(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x7(%rbp),%esi
movzbl -0x5(%rbp),%edx
movzbl -0x10(%rbp),%ecx
movzbl -0x10(%rbp),%r8d
lea    0xd77(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd85(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x5(%rbp),%esi
movzbl -0x6(%rbp),%edx
movzbl -0x11(%rbp),%ecx
movzbl -0x11(%rbp),%r8d
lea    0xd8b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x6(%rbp),%esi
movzbl -0x7(%rbp),%edx
movzbl -0x12(%rbp),%ecx
movzbl -0x12(%rbp),%r8d
lea    0xd6c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x7(%rbp),%esi
movzbl -0x5(%rbp),%edx
movzbl -0x13(%rbp),%ecx
movzbl -0x13(%rbp),%r8d
lea    0xd4d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd5b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x5(%rbp),%esi
movzbl -0x14(%rbp),%ecx
movzbl -0x14(%rbp),%r8d
lea    0xd5d(%rip),%rdi
mov    $0x1,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x6(%rbp),%esi
movzbl -0x15(%rbp),%ecx
movzbl -0x15(%rbp),%r8d
lea    0xd3d(%rip),%rdi
mov    $0x2,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x7(%rbp),%esi
movzbl -0x16(%rbp),%ecx
movzbl -0x16(%rbp),%r8d
lea    0xd1d(%rip),%rdi
mov    $0x3,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x7(%rbp),%esi
mov    -0x1c(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
lea    0xd1b(%rip),%rdi
mov    $0x3,%edx
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd44(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x5(%rbp),%esi
movzbl -0x1d(%rbp),%ecx
movzbl -0x1d(%rbp),%r8d
lea    0xcd1(%rip),%rdi
mov    $0x1,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x6(%rbp),%esi
movzbl -0x1e(%rbp),%ecx
movzbl -0x1e(%rbp),%r8d
lea    0xcb1(%rip),%rdi
mov    $0x2,%edx
mov    $0x0,%al
call   1030 <printf@plt>
movzbl -0x7(%rbp),%esi
movzbl -0x1f(%rbp),%ecx
movzbl -0x1f(%rbp),%r8d
lea    0xc91(%rip),%rdi
mov    $0x3,%edx
mov    $0x0,%al
call   1030 <printf@plt>
mov    0x2b30(%rip),%rax
mov    (%rax),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
lea    0xf9b(%rip),%rdi
call   1030 <puts@plt>
lea    0xfbd(%rip),%rdi
call   1030 <puts@plt>
lea    0xec0(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1f,%esi
mov    $0xe0,%edx
mov    $0xe0,%ecx
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0xf5,%edx
mov    $0xf5,%ecx
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0x49,%esi
mov    $0xb6,%edx
mov    $0xb6,%ecx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf7f(%rip),%rdi
call   1030 <puts@plt>
lea    0xe79(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1f,%esi
mov    $0xa,%edx
mov    $0xa,%ecx
mov    $0xa,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0x49,%edx
mov    $0x8,%ecx
mov    $0x8,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0x49,%esi
mov    $0x1f,%edx
mov    $0x9,%ecx
mov    $0x9,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf22(%rip),%rdi
call   1030 <puts@plt>
lea    0xe25(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1f,%esi
mov    $0xa,%edx
mov    $0x1f,%ecx
mov    $0x1f,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0x49,%edx
mov    $0x4b,%ecx
mov    $0x4b,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0x49,%esi
mov    $0x1f,%edx
mov    $0x5f,%ecx
mov    $0x5f,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xece(%rip),%rdi
call   1030 <puts@plt>
lea    0xdd1(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1f,%esi
mov    $0xa,%edx
mov    $0x15,%ecx
mov    $0x15,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0x49,%edx
mov    $0x43,%ecx
mov    $0x43,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0x49,%esi
mov    $0x1f,%edx
mov    $0x56,%ecx
mov    $0x56,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe82(%rip),%rdi
call   1030 <puts@plt>
lea    0xd7d(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1f,%esi
mov    $0x1,%edx
mov    $0x3e,%ecx
mov    $0x3e,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0x2,%edx
mov    $0x28,%ecx
mov    $0x28,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0x49,%esi
mov    $0x3,%edx
mov    $0x48,%ecx
mov    $0x48,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xd35(%rip),%rdi
mov    $0x49,%esi
mov    $0x3,%edx
mov    $0x248,%ecx
mov    $0x248,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe0b(%rip),%rdi
call   1030 <puts@plt>
mov    %rbx,%rdi
mov    $0x1f,%esi
mov    $0x1,%edx
mov    $0xf,%ecx
mov    $0xf,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0x2,%edx
mov    $0x2,%ecx
mov    $0x2,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    $0x49,%esi
mov    $0x3,%edx
mov    $0x9,%ecx
mov    $0x9,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c02(%rip),%rax
mov    (%rax),%eax
pop    %rbx
ret

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

LLVM IR (-O2):
@.str.2 = [23 x i8] c" ~%d = %3d (hex: %#x)\0A\00"
@.str.4 = [28 x i8] c"%3d & %3d = %3d (hex: %#x)\0A\00"
@.str.6 = [28 x i8] c"%3d | %3d = %3d (hex: %#x)\0A\00"
@.str.8 = [28 x i8] c"%3d ^ %3d = %3d (hex: %#x)\0A\00"
@.str.10 = [28 x i8] c"%3d <<%3d = %3d (hex: %#x)\0A\00"
@.str.11 = [60 x i8] c"%3d <<%3d = %3d (hex: %#x) - unsigned int (4 byte: 32 bit)\0A\00"
@EXIT_SUCCESS = global i32 0
@str = [46 x i8] c"I'm working on unsigned char (1 byte: 8 bit)\0A\00"
@str.13 = [32 x i8] c"One's complement operator ( ~ )\00"
@str.14 = [19 x i8] c"\0ABitwise AND ( & )\00"
@str.15 = [28 x i8] c"\0ABitwise inclusvie OR ( | )\00"
@str.16 = [36 x i8] c"\0ABitwise exclusvie OR, or XOR ( ^ )\00"
@str.17 = [28 x i8] c"\0ALeft shift operator ( << )\00"
@str.18 = [29 x i8] c"\0ARight shift operator ( >> )\00"
define i32 @main() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str, i64 0, i64 0))
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.13, i64 0, i64 0))
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 31, i32 224, i32 224)
%4 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 10, i32 245, i32 245)
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.2, i64 0, i64 0), i32 73, i32 182, i32 182)
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.14, i64 0, i64 0))
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.4, i64 0, i64 0), i32 31, i32 10, i32 10, i32 10)
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.4, i64 0, i64 0), i32 10, i32 73, i32 8, i32 8)
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.4, i64 0, i64 0), i32 73, i32 31, i32 9, i32 9)
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.15, i64 0, i64 0))
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.6, i64 0, i64 0), i32 31, i32 10, i32 31, i32 31)
%12 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.6, i64 0, i64 0), i32 10, i32 73, i32 75, i32 75)
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.6, i64 0, i64 0), i32 73, i32 31, i32 95, i32 95)
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str.16, i64 0, i64 0))
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.8, i64 0, i64 0), i32 31, i32 10, i32 21, i32 21)
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.8, i64 0, i64 0), i32 10, i32 73, i32 67, i32 67)
%17 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.8, i64 0, i64 0), i32 73, i32 31, i32 86, i32 86)
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.17, i64 0, i64 0))
%19 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i32 31, i32 1, i32 62, i32 62)
%20 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i32 10, i32 2, i32 40, i32 40)
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i32 73, i32 3, i32 72, i32 72)
%22 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.11, i64 0, i64 0), i32 73, i32 3, i32 584, i32 584)
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.18, i64 0, i64 0))
%24 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i32 31, i32 1, i32 15, i32 15)
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i32 10, i32 2, i32 2, i32 2)
%26 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i32 73, i32 3, i32 9, i32 9)
%27 = load i32, i32* @EXIT_SUCCESS
ret i32 %27
}