int main() {
  unsigned char a, b, c, d, e, f, g, h, i, j;
  a = 0xFF;
  b = 0xFF;
  c = a | b;
  c = 0;
  d = a & b;
  d = 0;
  e = a ^ b;
  e = 0;
  f = ~(a | b);
  f = 0;
  g = ~(a & b);
  g = 0;
  h = ~(a ^ b);
  h = 0;
  i = ~a;
  i = 0;
  j = ~b;
  j = 0;
  a = 0x0F;
  b = 0xF0;
  c = a | b;
  c = 0;
  d = a & b;
  d = 0;
  e = a ^ b;
  e = 0;
  f = ~(a | b);
  f = 0;
  g = ~(a & b);
  g = 0;
  h = ~(a ^ b);
  h = 0;
  i = ~a;
  i = 0;
  j = ~b;
  j = 0;
  a = 0xFF;
  b = 0x00;
  c = a | b;
  c = 0;
  d = a & b;
  d = 0;
  e = a ^ b;
  e = 0;
  f = ~(a | b);
  f = 0;
  g = ~(a & b);
  g = 0;
  h = ~(a ^ b);
  h = 0;
  i = ~a;
  i = 0;
  j = ~b;
  j = 0;
  a = 0x55;
  b = 0xAA;
  c = a | b;
  c = 0;
  d = a & b;
  d = 0;
  e = a ^ b;
  e = 0;
  f = ~(a | b);
  f = 0;
  g = ~(a & b);
  g = 0;
  h = ~(a ^ b);
  h = 0;
  i = ~a;
  i = 0;
  j = ~b;
  j = 0;
  a = 0x00;
  b = 0x00;
  c = a | b;
  c = 0;
  d = a & b;
  d = 0;
  e = a ^ b;
  e = 0;
  f = ~(a | b);
  f = 0;
  g = ~(a & b);
  g = 0;
  h = ~(a ^ b);
  h = 0;
  i = ~a;
  i = 0;
  j = ~b;
  j = 0;
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
movl   $0x0,-0x4(%rbp)
movb   $0xff,-0x5(%rbp)
movb   $0xff,-0x6(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0x7(%rbp)
movb   $0x0,-0x7(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
mov    %al,-0x8(%rbp)
movb   $0x0,-0x8(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
movb   $0x0,-0x9(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xa(%rbp)
movb   $0x0,-0xa(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xb(%rbp)
movb   $0x0,-0xb(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xc(%rbp)
movb   $0x0,-0xc(%rbp)
movzbl -0x5(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xd(%rbp)
movb   $0x0,-0xd(%rbp)
movzbl -0x6(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xe(%rbp)
movb   $0x0,-0xe(%rbp)
movb   $0xf,-0x5(%rbp)
movb   $0xf0,-0x6(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0x7(%rbp)
movb   $0x0,-0x7(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
mov    %al,-0x8(%rbp)
movb   $0x0,-0x8(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
movb   $0x0,-0x9(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xa(%rbp)
movb   $0x0,-0xa(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xb(%rbp)
movb   $0x0,-0xb(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xc(%rbp)
movb   $0x0,-0xc(%rbp)
movzbl -0x5(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xd(%rbp)
movb   $0x0,-0xd(%rbp)
movzbl -0x6(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xe(%rbp)
movb   $0x0,-0xe(%rbp)
movb   $0xff,-0x5(%rbp)
movb   $0x0,-0x6(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0x7(%rbp)
movb   $0x0,-0x7(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
mov    %al,-0x8(%rbp)
movb   $0x0,-0x8(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
movb   $0x0,-0x9(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xa(%rbp)
movb   $0x0,-0xa(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xb(%rbp)
movb   $0x0,-0xb(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xc(%rbp)
movb   $0x0,-0xc(%rbp)
movzbl -0x5(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xd(%rbp)
movb   $0x0,-0xd(%rbp)
movzbl -0x6(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xe(%rbp)
movb   $0x0,-0xe(%rbp)
movb   $0x55,-0x5(%rbp)
movb   $0xaa,-0x6(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0x7(%rbp)
movb   $0x0,-0x7(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
mov    %al,-0x8(%rbp)
movb   $0x0,-0x8(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
movb   $0x0,-0x9(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xa(%rbp)
movb   $0x0,-0xa(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xb(%rbp)
movb   $0x0,-0xb(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xc(%rbp)
movb   $0x0,-0xc(%rbp)
movzbl -0x5(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xd(%rbp)
movb   $0x0,-0xd(%rbp)
movzbl -0x6(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xe(%rbp)
movb   $0x0,-0xe(%rbp)
movb   $0x0,-0x5(%rbp)
movb   $0x0,-0x6(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
mov    %al,-0x7(%rbp)
movb   $0x0,-0x7(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
mov    %al,-0x8(%rbp)
movb   $0x0,-0x8(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x9(%rbp)
movb   $0x0,-0x9(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
or     %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xa(%rbp)
movb   $0x0,-0xa(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
and    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xb(%rbp)
movb   $0x0,-0xb(%rbp)
movzbl -0x5(%rbp),%eax
movzbl -0x6(%rbp),%ecx
xor    %ecx,%eax
xor    $0xffffffff,%eax
mov    %al,-0xc(%rbp)
movb   $0x0,-0xc(%rbp)
movzbl -0x5(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xd(%rbp)
movb   $0x0,-0xd(%rbp)
movzbl -0x6(%rbp),%eax
xor    $0xffffffff,%eax
mov    %al,-0xe(%rbp)
movb   $0x0,-0xe(%rbp)
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
xor    %eax,%eax
ret

LLVM IR (-O0):
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
store i32 0, i32* %1
store i8 -1, i8* %2
store i8 -1, i8* %3
%12 = load i8, i8* %2
%13 = zext i8 %12 to i32
%14 = load i8, i8* %3
%15 = zext i8 %14 to i32
%16 = or i32 %13, %15
%17 = trunc i32 %16 to i8
store i8 %17, i8* %4
store i8 0, i8* %4
%18 = load i8, i8* %2
%19 = zext i8 %18 to i32
%20 = load i8, i8* %3
%21 = zext i8 %20 to i32
%22 = and i32 %19, %21
%23 = trunc i32 %22 to i8
store i8 %23, i8* %5
store i8 0, i8* %5
%24 = load i8, i8* %2
%25 = zext i8 %24 to i32
%26 = load i8, i8* %3
%27 = zext i8 %26 to i32
%28 = xor i32 %25, %27
%29 = trunc i32 %28 to i8
store i8 %29, i8* %6
store i8 0, i8* %6
%30 = load i8, i8* %2
%31 = zext i8 %30 to i32
%32 = load i8, i8* %3
%33 = zext i8 %32 to i32
%34 = or i32 %31, %33
%35 = xor i32 %34, -1
%36 = trunc i32 %35 to i8
store i8 %36, i8* %7
store i8 0, i8* %7
%37 = load i8, i8* %2
%38 = zext i8 %37 to i32
%39 = load i8, i8* %3
%40 = zext i8 %39 to i32
%41 = and i32 %38, %40
%42 = xor i32 %41, -1
%43 = trunc i32 %42 to i8
store i8 %43, i8* %8
store i8 0, i8* %8
%44 = load i8, i8* %2
%45 = zext i8 %44 to i32
%46 = load i8, i8* %3
%47 = zext i8 %46 to i32
%48 = xor i32 %45, %47
%49 = xor i32 %48, -1
%50 = trunc i32 %49 to i8
store i8 %50, i8* %9
store i8 0, i8* %9
%51 = load i8, i8* %2
%52 = zext i8 %51 to i32
%53 = xor i32 %52, -1
%54 = trunc i32 %53 to i8
store i8 %54, i8* %10
store i8 0, i8* %10
%55 = load i8, i8* %3
%56 = zext i8 %55 to i32
%57 = xor i32 %56, -1
%58 = trunc i32 %57 to i8
store i8 %58, i8* %11
store i8 0, i8* %11
store i8 15, i8* %2
store i8 -16, i8* %3
%59 = load i8, i8* %2
%60 = zext i8 %59 to i32
%61 = load i8, i8* %3
%62 = zext i8 %61 to i32
%63 = or i32 %60, %62
%64 = trunc i32 %63 to i8
store i8 %64, i8* %4
store i8 0, i8* %4
%65 = load i8, i8* %2
%66 = zext i8 %65 to i32
%67 = load i8, i8* %3
%68 = zext i8 %67 to i32
%69 = and i32 %66, %68
%70 = trunc i32 %69 to i8
store i8 %70, i8* %5
store i8 0, i8* %5
%71 = load i8, i8* %2
%72 = zext i8 %71 to i32
%73 = load i8, i8* %3
%74 = zext i8 %73 to i32
%75 = xor i32 %72, %74
%76 = trunc i32 %75 to i8
store i8 %76, i8* %6
store i8 0, i8* %6
%77 = load i8, i8* %2
%78 = zext i8 %77 to i32
%79 = load i8, i8* %3
%80 = zext i8 %79 to i32
%81 = or i32 %78, %80
%82 = xor i32 %81, -1
%83 = trunc i32 %82 to i8
store i8 %83, i8* %7
store i8 0, i8* %7
%84 = load i8, i8* %2
%85 = zext i8 %84 to i32
%86 = load i8, i8* %3
%87 = zext i8 %86 to i32
%88 = and i32 %85, %87
%89 = xor i32 %88, -1
%90 = trunc i32 %89 to i8
store i8 %90, i8* %8
store i8 0, i8* %8
%91 = load i8, i8* %2
%92 = zext i8 %91 to i32
%93 = load i8, i8* %3
%94 = zext i8 %93 to i32
%95 = xor i32 %92, %94
%96 = xor i32 %95, -1
%97 = trunc i32 %96 to i8
store i8 %97, i8* %9
store i8 0, i8* %9
%98 = load i8, i8* %2
%99 = zext i8 %98 to i32
%100 = xor i32 %99, -1
%101 = trunc i32 %100 to i8
store i8 %101, i8* %10
store i8 0, i8* %10
%102 = load i8, i8* %3
%103 = zext i8 %102 to i32
%104 = xor i32 %103, -1
%105 = trunc i32 %104 to i8
store i8 %105, i8* %11
store i8 0, i8* %11
store i8 -1, i8* %2
store i8 0, i8* %3
%106 = load i8, i8* %2
%107 = zext i8 %106 to i32
%108 = load i8, i8* %3
%109 = zext i8 %108 to i32
%110 = or i32 %107, %109
%111 = trunc i32 %110 to i8
store i8 %111, i8* %4
store i8 0, i8* %4
%112 = load i8, i8* %2
%113 = zext i8 %112 to i32
%114 = load i8, i8* %3
%115 = zext i8 %114 to i32
%116 = and i32 %113, %115
%117 = trunc i32 %116 to i8
store i8 %117, i8* %5
store i8 0, i8* %5
%118 = load i8, i8* %2
%119 = zext i8 %118 to i32
%120 = load i8, i8* %3
%121 = zext i8 %120 to i32
%122 = xor i32 %119, %121
%123 = trunc i32 %122 to i8
store i8 %123, i8* %6
store i8 0, i8* %6
%124 = load i8, i8* %2
%125 = zext i8 %124 to i32
%126 = load i8, i8* %3
%127 = zext i8 %126 to i32
%128 = or i32 %125, %127
%129 = xor i32 %128, -1
%130 = trunc i32 %129 to i8
store i8 %130, i8* %7
store i8 0, i8* %7
%131 = load i8, i8* %2
%132 = zext i8 %131 to i32
%133 = load i8, i8* %3
%134 = zext i8 %133 to i32
%135 = and i32 %132, %134
%136 = xor i32 %135, -1
%137 = trunc i32 %136 to i8
store i8 %137, i8* %8
store i8 0, i8* %8
%138 = load i8, i8* %2
%139 = zext i8 %138 to i32
%140 = load i8, i8* %3
%141 = zext i8 %140 to i32
%142 = xor i32 %139, %141
%143 = xor i32 %142, -1
%144 = trunc i32 %143 to i8
store i8 %144, i8* %9
store i8 0, i8* %9
%145 = load i8, i8* %2
%146 = zext i8 %145 to i32
%147 = xor i32 %146, -1
%148 = trunc i32 %147 to i8
store i8 %148, i8* %10
store i8 0, i8* %10
%149 = load i8, i8* %3
%150 = zext i8 %149 to i32
%151 = xor i32 %150, -1
%152 = trunc i32 %151 to i8
store i8 %152, i8* %11
store i8 0, i8* %11
store i8 85, i8* %2
store i8 -86, i8* %3
%153 = load i8, i8* %2
%154 = zext i8 %153 to i32
%155 = load i8, i8* %3
%156 = zext i8 %155 to i32
%157 = or i32 %154, %156
%158 = trunc i32 %157 to i8
store i8 %158, i8* %4
store i8 0, i8* %4
%159 = load i8, i8* %2
%160 = zext i8 %159 to i32
%161 = load i8, i8* %3
%162 = zext i8 %161 to i32
%163 = and i32 %160, %162
%164 = trunc i32 %163 to i8
store i8 %164, i8* %5
store i8 0, i8* %5
%165 = load i8, i8* %2
%166 = zext i8 %165 to i32
%167 = load i8, i8* %3
%168 = zext i8 %167 to i32
%169 = xor i32 %166, %168
%170 = trunc i32 %169 to i8
store i8 %170, i8* %6
store i8 0, i8* %6
%171 = load i8, i8* %2
%172 = zext i8 %171 to i32
%173 = load i8, i8* %3
%174 = zext i8 %173 to i32
%175 = or i32 %172, %174
%176 = xor i32 %175, -1
%177 = trunc i32 %176 to i8
store i8 %177, i8* %7
store i8 0, i8* %7
%178 = load i8, i8* %2
%179 = zext i8 %178 to i32
%180 = load i8, i8* %3
%181 = zext i8 %180 to i32
%182 = and i32 %179, %181
%183 = xor i32 %182, -1
%184 = trunc i32 %183 to i8
store i8 %184, i8* %8
store i8 0, i8* %8
%185 = load i8, i8* %2
%186 = zext i8 %185 to i32
%187 = load i8, i8* %3
%188 = zext i8 %187 to i32
%189 = xor i32 %186, %188
%190 = xor i32 %189, -1
%191 = trunc i32 %190 to i8
store i8 %191, i8* %9
store i8 0, i8* %9
%192 = load i8, i8* %2
%193 = zext i8 %192 to i32
%194 = xor i32 %193, -1
%195 = trunc i32 %194 to i8
store i8 %195, i8* %10
store i8 0, i8* %10
%196 = load i8, i8* %3
%197 = zext i8 %196 to i32
%198 = xor i32 %197, -1
%199 = trunc i32 %198 to i8
store i8 %199, i8* %11
store i8 0, i8* %11
store i8 0, i8* %2
store i8 0, i8* %3
%200 = load i8, i8* %2
%201 = zext i8 %200 to i32
%202 = load i8, i8* %3
%203 = zext i8 %202 to i32
%204 = or i32 %201, %203
%205 = trunc i32 %204 to i8
store i8 %205, i8* %4
store i8 0, i8* %4
%206 = load i8, i8* %2
%207 = zext i8 %206 to i32
%208 = load i8, i8* %3
%209 = zext i8 %208 to i32
%210 = and i32 %207, %209
%211 = trunc i32 %210 to i8
store i8 %211, i8* %5
store i8 0, i8* %5
%212 = load i8, i8* %2
%213 = zext i8 %212 to i32
%214 = load i8, i8* %3
%215 = zext i8 %214 to i32
%216 = xor i32 %213, %215
%217 = trunc i32 %216 to i8
store i8 %217, i8* %6
store i8 0, i8* %6
%218 = load i8, i8* %2
%219 = zext i8 %218 to i32
%220 = load i8, i8* %3
%221 = zext i8 %220 to i32
%222 = or i32 %219, %221
%223 = xor i32 %222, -1
%224 = trunc i32 %223 to i8
store i8 %224, i8* %7
store i8 0, i8* %7
%225 = load i8, i8* %2
%226 = zext i8 %225 to i32
%227 = load i8, i8* %3
%228 = zext i8 %227 to i32
%229 = and i32 %226, %228
%230 = xor i32 %229, -1
%231 = trunc i32 %230 to i8
store i8 %231, i8* %8
store i8 0, i8* %8
%232 = load i8, i8* %2
%233 = zext i8 %232 to i32
%234 = load i8, i8* %3
%235 = zext i8 %234 to i32
%236 = xor i32 %233, %235
%237 = xor i32 %236, -1
%238 = trunc i32 %237 to i8
store i8 %238, i8* %9
store i8 0, i8* %9
%239 = load i8, i8* %2
%240 = zext i8 %239 to i32
%241 = xor i32 %240, -1
%242 = trunc i32 %241 to i8
store i8 %242, i8* %10
store i8 0, i8* %10
%243 = load i8, i8* %3
%244 = zext i8 %243 to i32
%245 = xor i32 %244, -1
%246 = trunc i32 %245 to i8
store i8 %246, i8* %11
store i8 0, i8* %11
ret i32 0
}

LLVM IR (-O2):
define i32 @main() {
ret i32 0
}