#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 *, unsigned char, ...);
void binaryfunk(unsigned char *bits) {
  unsigned char sign = (bits[3] & (0x80)) >> 7;
  sign += 48;
  unsigned char exponent[8];
  unsigned char mantissa[23];
  int i;
  int j;
  int k;
  int p;
  unsigned char realexp = 0;
  char realout = 0;
  for (i = 0; i < 7; i++) {
    j = 1;
    for (k = 6; k > i; k--) {
      j *= 2;
    }
    exponent[i] = (bits[3] & (j)) / j;
    exponent[i] += 48;
    if (exponent[i] == 49) {
      realexp |= 2 * j;
    }
  }
  exponent[7] = (bits[2] & 0x80) >> 7;
  exponent[7] += 48;
  if (exponent[7] == 49) {
    realexp |= 0x01;
  }
  realexp -= 0b01111000;
  for (i = 0; i < 7; i++) {
    j = 1;
    for (k = 6; k > i; k--) {
      j *= 2;
    }
    mantissa[i] = ((bits[2] & (j)) / j);
    mantissa[i] += 48;
  }
  for (i = 7; i < 15; i++) {
    mantissa[i] = ((bits[1] & ((14 - i) << 1)) >> (14 - i));
    mantissa[i] += 48;
  }
  for (i = 15; i < 23; i++) {
    mantissa[i] = (bits[0] & ((22 - i) << 1)) >> (22 - i);
    mantissa[i] += 48;
  }
  j = 1;
  for (k = 0; k < realexp; k++) {
    j *= 2;
  }
  realout |= j;
  for (i = realexp, p = 0; i > 0; i--, p++) {
    if (mantissa[p] == 49) {
      j = 1;
      for (k = 0; k < i - 1; k++) {
        j *= 2;
      }
      realout |= j;
    }
  }
  if (sign == 49) {
    realout *= -1;
  }
  printf("sign %c	exponent %s	mantissa %s\n", sign, exponent,
         mantissa);
  printf("%i %i\n", realexp, realout);
}


x86 assembly (clang, -O0):
<binaryfunk>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0x80,%eax
sar    $0x7,%eax
mov    %al,-0x9(%rbp)
movzbl -0x9(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x9(%rbp)
movb   $0x0,-0x41(%rbp)
movb   $0x0,-0x42(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x7,-0x34(%rbp)
jge    11e0 <binaryfunk+0xd0>
movl   $0x1,-0x38(%rbp)
movl   $0x6,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    1183 <binaryfunk+0x73>
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1160 <binaryfunk+0x50>
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
and    -0x38(%rbp),%eax
cltd
idivl  -0x38(%rbp)
mov    %al,%cl
movslq -0x34(%rbp),%rax
mov    %cl,-0x11(%rbp,%rax,1)
movslq -0x34(%rbp),%rax
movzbl -0x11(%rbp,%rax,1),%ecx
add    $0x30,%ecx
mov    %cl,-0x11(%rbp,%rax,1)
movslq -0x34(%rbp),%rax
movzbl -0x11(%rbp,%rax,1),%eax
cmp    $0x31,%eax
jne    11cd <binaryfunk+0xbd>
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
movzbl -0x41(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x41(%rbp)
jmp    11d2 <binaryfunk+0xc2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1148 <binaryfunk+0x38>
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0x80,%eax
sar    $0x7,%eax
mov    %al,-0xa(%rbp)
movzbl -0xa(%rbp),%eax
add    $0x30,%eax
mov    %al,-0xa(%rbp)
movzbl -0xa(%rbp),%eax
cmp    $0x31,%eax
jne    1214 <binaryfunk+0x104>
movzbl -0x41(%rbp),%eax
or     $0x1,%eax
mov    %al,-0x41(%rbp)
movzbl -0x41(%rbp),%eax
sub    $0x78,%eax
mov    %al,-0x41(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x7,-0x34(%rbp)
jge    1297 <binaryfunk+0x187>
movl   $0x1,-0x38(%rbp)
movl   $0x6,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    1260 <binaryfunk+0x150>
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    123d <binaryfunk+0x12d>
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
and    -0x38(%rbp),%eax
cltd
idivl  -0x38(%rbp)
mov    %al,%cl
movslq -0x34(%rbp),%rax
mov    %cl,-0x30(%rbp,%rax,1)
movslq -0x34(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
add    $0x30,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1225 <binaryfunk+0x115>
movl   $0x7,-0x34(%rbp)
cmpl   $0xf,-0x34(%rbp)
jge    12ef <binaryfunk+0x1df>
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    $0xe,%ecx
sub    -0x34(%rbp),%ecx
shl    $0x1,%ecx
and    %ecx,%eax
mov    $0xe,%ecx
sub    -0x34(%rbp),%ecx
sar    %cl,%eax
mov    %al,%cl
movslq -0x34(%rbp),%rax
mov    %cl,-0x30(%rbp,%rax,1)
movslq -0x34(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
add    $0x30,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    129e <binaryfunk+0x18e>
movl   $0xf,-0x34(%rbp)
cmpl   $0x17,-0x34(%rbp)
jge    1346 <binaryfunk+0x236>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    $0x16,%ecx
sub    -0x34(%rbp),%ecx
shl    $0x1,%ecx
and    %ecx,%eax
mov    $0x16,%ecx
sub    -0x34(%rbp),%ecx
sar    %cl,%eax
mov    %al,%cl
movslq -0x34(%rbp),%rax
mov    %cl,-0x30(%rbp,%rax,1)
movslq -0x34(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
add    $0x30,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12f6 <binaryfunk+0x1e6>
movl   $0x1,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
movzbl -0x41(%rbp),%ecx
cmp    %ecx,%eax
jge    137a <binaryfunk+0x26a>
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1354 <binaryfunk+0x244>
mov    -0x38(%rbp),%ecx
movsbl -0x42(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x42(%rbp)
movzbl -0x41(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    140e <binaryfunk+0x2fe>
movslq -0x40(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%eax
cmp    $0x31,%eax
jne    13f2 <binaryfunk+0x2e2>
movl   $0x1,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13e6 <binaryfunk+0x2d6>
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13be <binaryfunk+0x2ae>
mov    -0x38(%rbp),%ecx
movsbl -0x42(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x42(%rbp)
jmp    13f7 <binaryfunk+0x2e7>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1394 <binaryfunk+0x284>
movzbl -0x9(%rbp),%eax
cmp    $0x31,%eax
jne    1425 <binaryfunk+0x315>
movsbl -0x42(%rbp),%eax
imul   $0xffffffff,%eax,%eax
mov    %al,-0x42(%rbp)
mov    -0x9(%rbp),%al
lea    -0x11(%rbp),%rdx
lea    -0x30(%rbp),%rcx
lea    0xbc9(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x41(%rbp),%al
movsbl -0x42(%rbp),%edx
lea    0xbd2(%rip),%rdi
movzbl %al,%esi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<binaryfunk>:
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    0x3(%rdi),%al
mov    %eax,%r8d
shr    $0x7,%r8b
mov    %eax,%ecx
shr    $0x6,%cl
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0x8(%rsp)
cmp    $0x31,%cl
sete   %cl
shl    $0x7,%cl
mov    %eax,%edx
shr    $0x5,%dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0x9(%rsp)
cmp    $0x31,%dl
sete   %dl
shl    $0x6,%dl
or     %cl,%dl
mov    %eax,%ecx
shr    $0x4,%cl
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0xa(%rsp)
cmp    $0x31,%cl
sete   %cl
shl    $0x5,%cl
or     %dl,%cl
mov    %eax,%edx
shr    $0x3,%dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0xb(%rsp)
cmp    $0x31,%dl
sete   %dl
shl    $0x4,%dl
or     %cl,%dl
mov    %eax,%ecx
shr    $0x2,%cl
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0xc(%rsp)
cmp    $0x31,%cl
sete   %cl
shl    $0x3,%cl
or     %dl,%cl
mov    %eax,%edx
shr    %dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0xd(%rsp)
cmp    $0x31,%dl
sete   %dl
shl    $0x2,%dl
or     %cl,%dl
and    $0x1,%al
or     $0x30,%al
mov    %al,0xe(%rsp)
cmp    $0x31,%al
sete   %bl
add    %bl,%bl
or     %dl,%bl
mov    0x2(%rdi),%cl
mov    %ecx,%eax
shr    $0x7,%al
or     $0x30,%al
mov    %al,0xf(%rsp)
cmp    $0x31,%al
sete   %al
or     %bl,%al
mov    %ecx,%edx
shr    $0x6,%dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0x10(%rsp)
mov    %ecx,%edx
shr    $0x5,%dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0x11(%rsp)
mov    %ecx,%edx
shr    $0x4,%dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0x12(%rsp)
mov    %ecx,%edx
shr    $0x3,%dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0x13(%rsp)
mov    %ecx,%edx
shr    $0x2,%dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0x14(%rsp)
mov    %ecx,%edx
shr    %dl
and    $0x1,%dl
or     $0x30,%dl
mov    %dl,0x15(%rsp)
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0x16(%rsp)
or     $0x30,%r8b
mov    0x1(%rdi),%cl
mov    %ecx,%edx
shr    $0x2,%dl
and    $0x1,%dl
or     $0x30,%dl
movb   $0x30,0x1b(%rsp)
movl   $0x30303030,0x17(%rsp)
30
mov    %dl,0x1c(%rsp)
shr    %cl
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0x1d(%rsp)
movb   $0x30,0x1e(%rsp)
mov    (%rdi),%cl
mov    %ecx,%edx
shr    $0x2,%dl
and    $0x1,%dl
or     $0x30,%dl
movb   $0x30,0x23(%rsp)
movl   $0x30303030,0x1f(%rsp)
30
mov    %dl,0x24(%rsp)
shr    %cl
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,0x25(%rsp)
movb   $0x30,0x26(%rsp)
add    $0x88,%al
movzbl %al,%r14d
test   %r14b,%r14b
je     12c8 <binaryfunk+0x1b8>
lea    -0x1(%r14),%r11d
mov    %r14d,%eax
and    $0x7,%eax
cmp    $0x7,%r11d
jae    12cf <binaryfunk+0x1bf>
mov    $0x1,%ecx
jmp    12e8 <binaryfunk+0x1d8>
mov    $0x1,%cl
jmp    1399 <binaryfunk+0x289>
mov    %r14d,%esi
and    $0xfffffff8,%esi
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
shl    $0x8,%ecx
add    $0xfffffff8,%esi
jne    12e0 <binaryfunk+0x1d0>
test   %eax,%eax
je     12f7 <binaryfunk+0x1e7>
nopl   0x0(%rax)
add    %ecx,%ecx
add    $0xffffffff,%eax
jne    12f0 <binaryfunk+0x1e0>
test   %r14d,%r14d
je     1399 <binaryfunk+0x289>
mov    %r14d,%esi
mov    $0xfffffffe,%r9d
add    %rsi,%r9
xor    %eax,%eax
mov    %r14d,%ebx
jmp    1333 <binaryfunk+0x223>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
or     %dil,%cl
add    $0xffffffff,%ebx
add    $0x1,%rax
add    $0xffffffff,%r11d
cmp    %rsi,%rax
je     1399 <binaryfunk+0x289>
cmpb   $0x31,0x10(%rsp,%rax,1)
jne    1323 <binaryfunk+0x213>
mov    $0x1,%edi
cmp    $0x2,%ebx
jl     1320 <binaryfunk+0x210>
mov    %r9d,%edx
sub    %eax,%edx
mov    %eax,%edi
not    %edi
lea    (%rsi,%rdi,1),%r10d
mov    $0x1,%edi
cmp    $0x7,%edx
jb     1378 <binaryfunk+0x268>
mov    %r11d,%edx
and    $0xfffffff8,%edx
mov    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
shl    $0x8,%edi
add    $0xfffffff8,%edx
jne    1370 <binaryfunk+0x260>
test   $0x7,%r10b
je     1320 <binaryfunk+0x210>
mov    %r11d,%edx
and    $0x7,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %edi,%edi
add    $0xffffffff,%edx
jne    1390 <binaryfunk+0x280>
jmp    1320 <binaryfunk+0x210>
movzbl %cl,%eax
neg    %cl
cmp    $0x31,%r8b
movzbl %cl,%ebx
cmovne %eax,%ebx
movzbl %r8b,%esi
lea    0xc4d(%rip),%rdi
lea    0x8(%rsp),%rdx
lea    0x10(%rsp),%rcx
xor    %eax,%eax
call   1030 <printf@plt>
movsbl %bl,%edx
lea    0xc53(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1030 <printf@plt>
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret

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

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