#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 */
scalar_t__ malloc(int);
const char **convert_compat(const char *compat, const size_t len) {
  int entries = 0;
  for (const char *p = compat; (size_t)(p - compat) < len; ++p) {
    if (*p == '\0')
      entries += 1;
  }
  const char **array = (const char **)malloc((entries + 1) * sizeof(char *));
  if (array == NULL)
    return NULL;
  int off = 0;
  for (int i = 0; i < entries; ++i) {
    array[i] = compat + off;
    while (compat[off] != '\0')
      off += 1;
    off += 1;
  }
  array[entries] = NULL;
  return array;
}


x86 assembly (clang, -O0):
<convert_compat>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
cmp    -0x18(%rbp),%rax
jae    1173 <convert_compat+0x63>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    115d <convert_compat+0x4d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1162 <convert_compat+0x52>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    112f <convert_compat+0x1f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    11a2 <convert_compat+0x92>
movq   $0x0,-0x8(%rbp)
jmp    1225 <convert_compat+0x115>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    120d <convert_compat+0xfd>
mov    -0x10(%rbp),%rdx
movslq -0x34(%rbp),%rax
add    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     11f6 <convert_compat+0xe6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11d3 <convert_compat+0xc3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11b0 <convert_compat+0xa0>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convert_compat>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
xor    %ebx,%ebx
test   %rsi,%rsi
je     1273 <convert_compat+0x163>
mov    %r14,%rax
cmp    $0x8,%rsi
jb     124d <convert_compat+0x13d>
mov    %rsi,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     137a <convert_compat+0x26a>
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm2,%xmm2
xor    %edx,%edx
movdqa 0xe9d(%rip),%xmm3
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movd   (%r14,%rdx,1),%xmm5
movd   0x4(%r14,%rdx,1),%xmm4
pcmpeqb %xmm2,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm0,%xmm5
pcmpeqb %xmm2,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%r14,%rdx,1),%xmm0
movd   0xc(%r14,%rdx,1),%xmm1
pcmpeqb %xmm2,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm3,%xmm0
paddd  %xmm5,%xmm0
pcmpeqb %xmm2,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm3,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1170 <convert_compat+0x60>
test   $0x1,%cl
je     122b <convert_compat+0x11b>
movd   (%r14,%rdx,1),%xmm2
movd   0x4(%r14,%rdx,1),%xmm3
pxor   %xmm4,%xmm4
pcmpeqb %xmm4,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
movdqa 0xdf1(%rip),%xmm5
pand   %xmm5,%xmm2
paddd  %xmm2,%xmm0
pcmpeqb %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm5,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %rsi,%rax
je     1273 <convert_compat+0x163>
add    %r14,%rax
mov    %rax,%rcx
sub    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpb   $0x1,(%rax)
adc    $0x0,%ebx
add    $0x1,%rax
add    $0x1,%rcx
cmp    %rsi,%rcx
jb     1260 <convert_compat+0x150>
lea    0x8(,%rbx,8),%edi
call   1030 <malloc@plt>
test   %rax,%rax
je     12a3 <convert_compat+0x193>
test   %ebx,%ebx
je     12aa <convert_compat+0x19a>
mov    %ebx,%r8d
cmp    $0x1,%ebx
jne    12b2 <convert_compat+0x1a2>
xor    %edx,%edx
xor    %esi,%esi
test   $0x1,%r8b
jne    1351 <convert_compat+0x241>
jmp    136a <convert_compat+0x25a>
xor    %eax,%eax
jmp    1372 <convert_compat+0x262>
xor    %r8d,%r8d
jmp    136a <convert_compat+0x25a>
movabs $0x100000000,%rdi
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
xor    %edx,%edx
movabs $0xffffffff00000000,%r9
ff ff ff
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rsi
shl    $0x20,%rsi
movslq %ebx,%rbx
add    %r14,%rbx
mov    %rbx,(%rax,%rdx,8)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %rdi,%rsi
cmpb   $0x0,(%rbx)
lea    0x1(%rbx),%rbx
jne    1300 <convert_compat+0x1f0>
lea    0x0(,%rdx,8),%rcx
mov    %rsi,%rbx
sar    $0x20,%rbx
lea    (%r14,%rbx,1),%r11
or     $0x8,%rcx
mov    %r11,(%rax,%rcx,1)
and    %r9,%rsi
nopw   0x0(%rax,%rax,1)
add    %rdi,%rsi
cmpb   $0x0,(%r14,%rbx,1)
lea    0x1(%rbx),%rbx
jne    1330 <convert_compat+0x220>
add    $0x2,%rdx
cmp    %r10,%rdx
jne    12e0 <convert_compat+0x1d0>
sar    $0x20,%rsi
test   $0x1,%r8b
je     136a <convert_compat+0x25a>
add    %rsi,%r14
mov    %r14,(%rax,%rdx,8)
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,(%r14)
lea    0x1(%r14),%r14
jne    1360 <convert_compat+0x250>
movq   $0x0,(%rax,%r8,8)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
test   $0x1,%cl
jne    11ea <convert_compat+0xda>
jmp    122b <convert_compat+0x11b>

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

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