#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 */
void char_to_int32(const char *text, unsigned int *text_32,
                   size_t text_length) {
  for (size_t i = 0; i < text_length; i += 4) {
    text_32[i / 4] = 0xFF000000 & ((unsigned int)text[i + 0] << 24);
    unsigned int tmp = 0x0;
    tmp = 0xFF0000 & ((unsigned int)text[i + 1] << 16);
    text_32[i / 4] = text_32[i / 4] | tmp;
    tmp = 0xFF00 & ((unsigned int)text[i + 2] << 8);
    text_32[i / 4] = text_32[i / 4] | tmp;
    tmp = 0xFF & ((unsigned int)text[i + 3]);
    text_32[i / 4] = text_32[i / 4] | tmp;
  }
}


x86 assembly (clang, -O0):
<char_to_int32>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    120a <char_to_int32+0x10a>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
shl    $0x18,%edx
and    $0xff000000,%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl 0x1(%rax,%rcx,1),%eax
shl    $0x10,%eax
and    $0xff0000,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
mov    (%rax,%rcx,4),%edx
or     -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl 0x2(%rax,%rcx,1),%eax
shl    $0x8,%eax
and    $0xff00,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
mov    (%rax,%rcx,4),%edx
or     -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl 0x3(%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
mov    (%rax,%rcx,4),%edx
or     -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
jmp    1118 <char_to_int32+0x18>
pop    %rbp
ret

x86 assembly (clang, -O2):
<char_to_int32>:
push   %rbp
push   %r14
push   %rbx
test   %rdx,%rdx
je     118e <char_to_int32+0x8e>
lea    -0x1(%rdx),%r8
cmp    $0xc,%r8
jb     113a <char_to_int32+0x3a>
lea    0x3(%rdx),%rax
and    $0xfffffffffffffffc,%rax
add    %rdi,%rax
cmp    %rsi,%rax
jbe    1193 <char_to_int32+0x93>
mov    %r8,%rax
and    $0xfffffffffffffffc,%rax
add    %rsi,%rax
add    $0x4,%rax
cmp    %rdi,%rax
jbe    1193 <char_to_int32+0x93>
xor    %eax,%eax
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
add    %rcx,%rsi
cs nopw 0x0(%rax,%rax,1)
movzbl (%rdi,%rax,1),%ecx
shl    $0x18,%ecx
mov    %ecx,(%rsi)
movzbl 0x1(%rdi,%rax,1),%ebp
movzbl %bpl,%ebp
shl    $0x10,%ebp
or     %ecx,%ebp
mov    %ebp,(%rsi)
movzbl 0x2(%rdi,%rax,1),%ecx
shl    $0x8,%ecx
movzwl %cx,%ecx
or     %ebp,%ecx
mov    %ecx,(%rsi)
movzbl 0x3(%rdi,%rax,1),%ebp
or     %ecx,%ebp
mov    %ebp,(%rsi)
add    $0x4,%rax
add    $0x4,%rsi
cmp    %rdx,%rax
jb     1150 <char_to_int32+0x50>
pop    %rbx
pop    %r14
pop    %rbp
ret
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    0x0(,%r9,4),%rax
xor    %ecx,%ecx
movabs $0x3ffffffffffffffc,%r10
ff ff 3f
movdqa 0xe42(%rip),%xmm0
movdqa 0xe4a(%rip),%xmm1
pxor   %xmm2,%xmm2
nopw   0x0(%rax,%rax,1)
movzbl 0x4(%rdi,%rcx,4),%r11d
movzbl (%rdi,%rcx,4),%ebx
movd   %ebx,%xmm3
pinsrw $0x2,%r11d,%xmm3
movzbl 0x8(%rdi,%rcx,4),%ebx
pinsrw $0x4,%ebx,%xmm3
movzbl 0xc(%rdi,%rcx,4),%ebx
pinsrw $0x6,%ebx,%xmm3
pslld  $0x18,%xmm3
mov    %rcx,%r11
and    %r10,%r11
movdqu %xmm3,(%rsi,%r11,4)
movzbl 0x5(%rdi,%rcx,4),%ebx
movzbl 0x1(%rdi,%rcx,4),%ebp
movd   %ebp,%xmm4
pinsrw $0x2,%ebx,%xmm4
movzbl 0x9(%rdi,%rcx,4),%ebx
pinsrw $0x4,%ebx,%xmm4
movzbl 0xd(%rdi,%rcx,4),%ebx
pinsrw $0x6,%ebx,%xmm4
pslld  $0x10,%xmm4
pand   %xmm0,%xmm4
por    %xmm3,%xmm4
movdqu %xmm4,(%rsi,%r11,4)
movzbl 0x6(%rdi,%rcx,4),%ebx
movzbl 0x2(%rdi,%rcx,4),%ebp
movd   %ebp,%xmm3
pinsrw $0x2,%ebx,%xmm3
movzbl 0xa(%rdi,%rcx,4),%ebx
pinsrw $0x4,%ebx,%xmm3
movzbl 0xe(%rdi,%rcx,4),%ebx
pinsrw $0x6,%ebx,%xmm3
pslld  $0x8,%xmm3
pand   %xmm1,%xmm3
por    %xmm4,%xmm3
movdqu %xmm3,(%rsi,%r11,4)
movzbl 0x3(%rdi,%rcx,4),%r14d
movzbl 0xb(%rdi,%rcx,4),%ebp
movzbl 0xf(%rdi,%rcx,4),%ebx
shl    $0x8,%ebx
or     %ebp,%ebx
movzbl 0x7(%rdi,%rcx,4),%ebp
shl    $0x8,%ebp
or     %r14d,%ebp
movd   %ebp,%xmm4
pinsrw $0x1,%ebx,%xmm4
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
por    %xmm3,%xmm4
movdqu %xmm4,(%rsi,%r11,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    11d0 <char_to_int32+0xd0>
cmp    %r9,%r8
je     118e <char_to_int32+0x8e>
jmp    113c <char_to_int32+0x3c>

LLVM IR (-O0):
define void @char_to_int32(i8* %0, i32* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i32*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i32
store i8* %0, i8** %4
store i32* %1, i32** %5
store i64 %2, i64* %6
store i64 0, i64* %7
br label %9
9: ; preds = %82, %3
%10 = load i64, i64* %7
%11 = load i64, i64* %6
%12 = icmp ult i64 %10, %11
br i1 %12, label %13, label %85
13: ; preds = %9
%14 = load i8*, i8** %4
%15 = load i64, i64* %7
%16 = add i64 %15, 0
%17 = getelementptr inbounds i8, i8* %14, i64 %16
%18 = load i8, i8* %17
%19 = sext i8 %18 to i32
%20 = shl i32 %19, 24
%21 = and i32 -16777216, %20
%22 = load i32*, i32** %5
%23 = load i64, i64* %7
%24 = udiv i64 %23, 4
%25 = getelementptr inbounds i32, i32* %22, i64 %24
store i32 %21, i32* %25
store i32 0, i32* %8
%26 = load i8*, i8** %4
%27 = load i64, i64* %7
%28 = add i64 %27, 1
%29 = getelementptr inbounds i8, i8* %26, i64 %28
%30 = load i8, i8* %29
%31 = sext i8 %30 to i32
%32 = shl i32 %31, 16
%33 = and i32 16711680, %32
store i32 %33, i32* %8
%34 = load i32*, i32** %5
%35 = load i64, i64* %7
%36 = udiv i64 %35, 4
%37 = getelementptr inbounds i32, i32* %34, i64 %36
%38 = load i32, i32* %37
%39 = load i32, i32* %8
%40 = or i32 %38, %39
%41 = load i32*, i32** %5
%42 = load i64, i64* %7
%43 = udiv i64 %42, 4
%44 = getelementptr inbounds i32, i32* %41, i64 %43
store i32 %40, i32* %44
%45 = load i8*, i8** %4
%46 = load i64, i64* %7
%47 = add i64 %46, 2
%48 = getelementptr inbounds i8, i8* %45, i64 %47
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
%51 = shl i32 %50, 8
%52 = and i32 65280, %51
store i32 %52, i32* %8
%53 = load i32*, i32** %5
%54 = load i64, i64* %7
%55 = udiv i64 %54, 4
%56 = getelementptr inbounds i32, i32* %53, i64 %55
%57 = load i32, i32* %56
%58 = load i32, i32* %8
%59 = or i32 %57, %58
%60 = load i32*, i32** %5
%61 = load i64, i64* %7
%62 = udiv i64 %61, 4
%63 = getelementptr inbounds i32, i32* %60, i64 %62
store i32 %59, i32* %63
%64 = load i8*, i8** %4
%65 = load i64, i64* %7
%66 = add i64 %65, 3
%67 = getelementptr inbounds i8, i8* %64, i64 %66
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
%70 = and i32 255, %69
store i32 %70, i32* %8
%71 = load i32*, i32** %5
%72 = load i64, i64* %7
%73 = udiv i64 %72, 4
%74 = getelementptr inbounds i32, i32* %71, i64 %73
%75 = load i32, i32* %74
%76 = load i32, i32* %8
%77 = or i32 %75, %76
%78 = load i32*, i32** %5
%79 = load i64, i64* %7
%80 = udiv i64 %79, 4
%81 = getelementptr inbounds i32, i32* %78, i64 %80
store i32 %77, i32* %81
br label %82
82: ; preds = %13
%83 = load i64, i64* %7
%84 = add i64 %83, 4
store i64 %84, i64* %7
br label %9
85: ; preds = %9
ret void
}

LLVM IR (-O2):
define void @char_to_int32(i8* nocapture %0, i32* nocapture writeonly %1, i64 %2) {
%4 = bitcast i32* %1 to i8*
%5 = icmp eq i64 %2, 0
br i1 %5, label %116, label %6
6: ; preds = %3
%7 = add i64 %2, -1
%8 = lshr i64 %7, 2
%9 = add nuw nsw i64 %8, 1
%10 = icmp ult i64 %7, 12
br i1 %10, label %114, label %11
11: ; preds = %6
%12 = add i64 %2, -1
%13 = lshr i64 %12, 2
%14 = add nuw nsw i64 %13, 1
%15 = getelementptr i32, i32* %1, i64 %14
%16 = bitcast i32* %15 to i8*
%17 = add i64 %2, 3
%18 = and i64 %17, -4
%19 = getelementptr i8, i8* %0, i64 %18
%20 = icmp ugt i8* %19, %4
%21 = icmp ugt i8* %16, %0
%22 = and i1 %20, %21
br i1 %22, label %114, label %23
23: ; preds = %11
%24 = and i64 %9, 9223372036854775804
%25 = shl i64 %24, 2
br label %26
26: ; preds = %26, %23
%27 = phi i64 [ 0, %23 ], [ %110, %26 ]
%28 = shl i64 %27, 2
%29 = or i64 %28, 4
%30 = or i64 %28, 8
%31 = or i64 %28, 12
%32 = getelementptr inbounds i8, i8* %0, i64 %28
%33 = getelementptr inbounds i8, i8* %0, i64 %29
%34 = getelementptr inbounds i8, i8* %0, i64 %30
%35 = getelementptr inbounds i8, i8* %0, i64 %31
%36 = load i8, i8* %32
%37 = load i8, i8* %33
%38 = load i8, i8* %34
%39 = load i8, i8* %35
%40 = insertelement <4 x i8> poison, i8 %36, i64 0
%41 = insertelement <4 x i8> %40, i8 %37, i64 1
%42 = insertelement <4 x i8> %41, i8 %38, i64 2
%43 = insertelement <4 x i8> %42, i8 %39, i64 3
%44 = zext <4 x i8> %43 to <4 x i32>
%45 = shl nuw <4 x i32> %44, <i32 24, i32 24, i32 24, i32 24>
%46 = and i64 %27, 4611686018427387900
%47 = getelementptr inbounds i32, i32* %1, i64 %46
%48 = bitcast i32* %47 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %48
%49 = or i64 %28, 1
%50 = or i64 %28, 5
%51 = or i64 %28, 9
%52 = or i64 %28, 13
%53 = getelementptr inbounds i8, i8* %0, i64 %49
%54 = getelementptr inbounds i8, i8* %0, i64 %50
%55 = getelementptr inbounds i8, i8* %0, i64 %51
%56 = getelementptr inbounds i8, i8* %0, i64 %52
%57 = load i8, i8* %53
%58 = load i8, i8* %54
%59 = load i8, i8* %55
%60 = load i8, i8* %56
%61 = insertelement <4 x i8> poison, i8 %57, i64 0
%62 = insertelement <4 x i8> %61, i8 %58, i64 1
%63 = insertelement <4 x i8> %62, i8 %59, i64 2
%64 = insertelement <4 x i8> %63, i8 %60, i64 3
%65 = sext <4 x i8> %64 to <4 x i32>
%66 = shl nsw <4 x i32> %65, <i32 16, i32 16, i32 16, i32 16>
%67 = and <4 x i32> %66, <i32 16711680, i32 16711680, i32 16711680, i32 16711680>
%68 = or <4 x i32> %67, %45
%69 = bitcast i32* %47 to <4 x i32>*
store <4 x i32> %68, <4 x i32>* %69
%70 = or i64 %28, 2
%71 = or i64 %28, 6
%72 = or i64 %28, 10
%73 = or i64 %28, 14
%74 = getelementptr inbounds i8, i8* %0, i64 %70
%75 = getelementptr inbounds i8, i8* %0, i64 %71
%76 = getelementptr inbounds i8, i8* %0, i64 %72
%77 = getelementptr inbounds i8, i8* %0, i64 %73
%78 = load i8, i8* %74
%79 = load i8, i8* %75
%80 = load i8, i8* %76
%81 = load i8, i8* %77
%82 = insertelement <4 x i8> poison, i8 %78, i64 0
%83 = insertelement <4 x i8> %82, i8 %79, i64 1
%84 = insertelement <4 x i8> %83, i8 %80, i64 2
%85 = insertelement <4 x i8> %84, i8 %81, i64 3
%86 = sext <4 x i8> %85 to <4 x i32>
%87 = shl nsw <4 x i32> %86, <i32 8, i32 8, i32 8, i32 8>
%88 = and <4 x i32> %87, <i32 65280, i32 65280, i32 65280, i32 65280>
%89 = or <4 x i32> %88, %68
%90 = bitcast i32* %47 to <4 x i32>*
store <4 x i32> %89, <4 x i32>* %90
%91 = or i64 %28, 3
%92 = or i64 %28, 7
%93 = or i64 %28, 11
%94 = or i64 %28, 15
%95 = getelementptr inbounds i8, i8* %0, i64 %91
%96 = getelementptr inbounds i8, i8* %0, i64 %92
%97 = getelementptr inbounds i8, i8* %0, i64 %93
%98 = getelementptr inbounds i8, i8* %0, i64 %94
%99 = load i8, i8* %95
%100 = load i8, i8* %96
%101 = load i8, i8* %97
%102 = load i8, i8* %98
%103 = insertelement <4 x i8> poison, i8 %99, i64 0
%104 = insertelement <4 x i8> %103, i8 %100, i64 1
%105 = insertelement <4 x i8> %104, i8 %101, i64 2
%106 = insertelement <4 x i8> %105, i8 %102, i64 3
%107 = zext <4 x i8> %106 to <4 x i32>
%108 = or <4 x i32> %89, %107
%109 = bitcast i32* %47 to <4 x i32>*
store <4 x i32> %108, <4 x i32>* %109
%110 = add nuw i64 %27, 4
%111 = icmp eq i64 %110, %24
br i1 %111, label %112, label %26
112: ; preds = %26
%113 = icmp eq i64 %9, %24
br i1 %113, label %116, label %114
114: ; preds = %11, %6, %112
%115 = phi i64 [ 0, %11 ], [ 0, %6 ], [ %25, %112 ]
br label %117
116: ; preds = %117, %112, %3
ret void
117: ; preds = %114, %117
%118 = phi i64 [ %144, %117 ], [ %115, %114 ]
%119 = getelementptr inbounds i8, i8* %0, i64 %118
%120 = load i8, i8* %119
%121 = zext i8 %120 to i32
%122 = shl nuw i32 %121, 24
%123 = lshr exact i64 %118, 2
%124 = getelementptr inbounds i32, i32* %1, i64 %123
store i32 %122, i32* %124
%125 = or i64 %118, 1
%126 = getelementptr inbounds i8, i8* %0, i64 %125
%127 = load i8, i8* %126
%128 = sext i8 %127 to i32
%129 = shl nsw i32 %128, 16
%130 = and i32 %129, 16711680
%131 = or i32 %130, %122
store i32 %131, i32* %124
%132 = or i64 %118, 2
%133 = getelementptr inbounds i8, i8* %0, i64 %132
%134 = load i8, i8* %133
%135 = sext i8 %134 to i32
%136 = shl nsw i32 %135, 8
%137 = and i32 %136, 65280
%138 = or i32 %137, %131
store i32 %138, i32* %124
%139 = or i64 %118, 3
%140 = getelementptr inbounds i8, i8* %0, i64 %139
%141 = load i8, i8* %140
%142 = zext i8 %141 to i32
%143 = or i32 %138, %142
store i32 %143, i32* %124
%144 = add nuw i64 %118, 4
%145 = icmp ult i64 %144, %2
br i1 %145, label %117, label %116
}