#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*/ gds_swap2bytes(unsigned char *);
scalar_t__ malloc(short);
short strlen(char *);
int /*<<< orphan*/ write(int, ...);
void gds_write_libname(int fd, char *s) {
  short int count, len, i, token;
  static int pad;
  static char *ps;
  len = strlen(s);
  pad = (len % 2) != 0;
  if (pad)
    len++;
  ps = (char *)malloc(len);
  if (pad) {
    for (i = 0; i < len - 1; i++)
      ps[i] = s[i];
    ps[len - 1] = 0;
  } else {
    for (i = 0; i < len; i++)
      ps[i] = s[i];
  }
  count = 4 + len;
  gds_swap2bytes((unsigned char *)&count);
  write(fd, &count, 2);
  token = 0x0206;
  gds_swap2bytes((unsigned char *)&token);
  write(fd, &token, 2);
  write(fd, ps, len);
}


x86 assembly (clang, -O0):
<gds_write_libname>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %ax,-0x14(%rbp)
movswl -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
setne  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,0x2ecf(%rip)
cmpl   $0x0,0x2ec8(%rip)
je     1192 <gds_write_libname+0x52>
mov    -0x14(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x14(%rbp)
movswl -0x14(%rbp),%edi
call   1060 <malloc@plt>
mov    %rax,0x2eae(%rip)
cmpl   $0x0,0x2e9f(%rip)
je     120e <gds_write_libname+0xce>
movw   $0x0,-0x16(%rbp)
movswl -0x16(%rbp),%eax
movswl -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11f4 <gds_write_libname+0xb4>
mov    -0x10(%rbp),%rax
movswq -0x16(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    0x2e75(%rip),%rax
movswq -0x16(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x16(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x16(%rbp)
jmp    11b5 <gds_write_libname+0x75>
mov    0x2e55(%rip),%rax
movswl -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1255 <gds_write_libname+0x115>
movw   $0x0,-0x16(%rbp)
movswl -0x16(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    1250 <gds_write_libname+0x110>
mov    -0x10(%rbp),%rax
movswq -0x16(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    0x2e19(%rip),%rax
movswq -0x16(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x16(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x16(%rbp)
jmp    1214 <gds_write_libname+0xd4>
jmp    1255 <gds_write_libname+0x115>
movswl -0x14(%rbp),%eax
add    $0x4,%eax
mov    %ax,-0x12(%rbp)
lea    -0x12(%rbp),%rdi
call   1050 <gds_swap2bytes@plt>
mov    -0x4(%rbp),%edi
lea    -0x12(%rbp),%rsi
mov    $0x2,%edx
mov    $0x0,%al
call   1030 <write@plt>
movw   $0x206,-0x18(%rbp)
lea    -0x18(%rbp),%rdi
call   1050 <gds_swap2bytes@plt>
mov    -0x4(%rbp),%edi
lea    -0x18(%rbp),%rsi
mov    $0x2,%edx
mov    $0x0,%al
call   1030 <write@plt>
mov    -0x4(%rbp),%edi
mov    0x2da8(%rip),%rsi
movswl -0x14(%rbp),%edx
mov    $0x0,%al
call   1030 <write@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gds_write_libname>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %edi,%r15d
mov    %rsi,%rdi
call   1040 <strlen@plt>
mov    %eax,%r12d
and    $0x1,%r12d
mov    %r12d,0x2ee1(%rip)
add    %eax,%r12d
movswl %r12w,%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x2ed4(%rip)
cmpl   $0x0,0x2ec5(%rip)
je     11a9 <gds_write_libname+0x69>
movswq %r12w,%r13
add    $0xffffffffffffffff,%r13
cmp    $0x2,%r12w
jl     1397 <gds_write_libname+0x257>
cmp    $0x8,%r13d
jae    1244 <gds_write_libname+0x104>
xor    %edx,%edx
jmp    1380 <gds_write_libname+0x240>
test   %r12w,%r12w
jle    139c <gds_write_libname+0x25c>
movzwl %r12w,%r9d
cmp    $0x8,%r12w
jb     11d8 <gds_write_libname+0x98>
lea    (%r14,%r9,1),%rdx
cmp    %rax,%rdx
jbe    140d <gds_write_libname+0x2cd>
lea    (%rax,%r9,1),%rdx
cmp    %r14,%rdx
jbe    140d <gds_write_libname+0x2cd>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdi
and    $0x3,%rdi
je     1202 <gds_write_libname+0xc2>
nopl   0x0(%rax)
movzbl (%r14,%rdx,1),%ecx
mov    %cl,(%rax,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    11f0 <gds_write_libname+0xb0>
cmp    $0x3,%rsi
jb     139c <gds_write_libname+0x25c>
nopl   0x0(%rax)
movzbl (%r14,%rdx,1),%ecx
mov    %cl,(%rax,%rdx,1)
movzbl 0x1(%r14,%rdx,1),%ecx
mov    %cl,0x1(%rax,%rdx,1)
movzbl 0x2(%r14,%rdx,1),%ecx
mov    %cl,0x2(%rax,%rdx,1)
movzbl 0x3(%r14,%rdx,1),%ecx
mov    %cl,0x3(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    1210 <gds_write_libname+0xd0>
jmp    139c <gds_write_libname+0x25c>
lea    -0x2(%rbp),%esi
movzwl %si,%edi
xor    %edx,%edx
cmp    $0x7ffe,%edi
ja     1380 <gds_write_libname+0x240>
cmp    $0x7fff,%esi
ja     1380 <gds_write_libname+0x240>
lea    (%r14,%rsi,1),%rdi
add    $0x1,%rdi
xor    %edx,%edx
cmp    %rax,%rdi
jbe    1283 <gds_write_libname+0x143>
add    %rax,%rsi
add    $0x1,%rsi
cmp    %r14,%rsi
ja     1380 <gds_write_libname+0x240>
cmp    $0x20,%r13d
jb     1341 <gds_write_libname+0x201>
mov    %r13d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%edi
mov    %edi,%r8d
shr    $0x5,%r8d
add    $0x1,%r8d
xor    %r11d,%r11d
test   %edi,%edi
je     131a <gds_write_libname+0x1da>
mov    %rbp,%rcx
mov    %r8d,%edi
and    $0xfffffffe,%edi
movabs $0x20000000000000,%r9
movabs $0x40000000000000,%r10
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    %rsi,%rbp
sar    $0x30,%rbp
movups (%r14,%rbp,1),%xmm0
movups 0x10(%r14,%rbp,1),%xmm1
movups %xmm0,(%rax,%rbp,1)
movups %xmm1,0x10(%rax,%rbp,1)
lea    (%rsi,%r9,1),%rbp
sar    $0x30,%rbp
movups (%r14,%rbp,1),%xmm0
movups 0x10(%r14,%rbp,1),%xmm1
movups %xmm0,(%rax,%rbp,1)
movups %xmm1,0x10(%rax,%rbp,1)
add    $0x40,%r11d
add    %r10,%rsi
add    $0xfffffffe,%edi
jne    12d0 <gds_write_libname+0x190>
movswq %r11w,%r11
mov    %rcx,%rbp
test   $0x1,%r8b
je     1336 <gds_write_libname+0x1f6>
movups (%r14,%r11,1),%xmm0
movups 0x10(%r14,%r11,1),%xmm1
movups %xmm0,(%rax,%r11,1)
movups %xmm1,0x10(%rax,%r11,1)
cmp    %edx,%r13d
je     1397 <gds_write_libname+0x257>
test   $0x18,%r13b
je     1380 <gds_write_libname+0x240>
mov    %rbp,%rbx
mov    %edx,%ebp
mov    %r13d,%edx
and    $0xfffffff8,%edx
mov    %rbp,%rsi
shl    $0x30,%rsi
sub    %edx,%ebp
movabs $0x8000000000000,%r8
nop
mov    %rsi,%rdi
sar    $0x30,%rdi
mov    (%r14,%rdi,1),%rcx
mov    %rcx,(%rax,%rdi,1)
add    %r8,%rsi
add    $0x8,%ebp
jne    1360 <gds_write_libname+0x220>
cmp    %edx,%r13d
mov    %rbx,%rbp
je     1397 <gds_write_libname+0x257>
nop
movswq %dx,%rcx
movzbl (%r14,%rcx,1),%ebx
mov    %bl,(%rax,%rcx,1)
add    $0x1,%edx
movswl %dx,%ecx
cmp    %ecx,%r13d
jg     1380 <gds_write_libname+0x240>
movb   $0x0,(%rax,%r13,1)
add    $0x4,%r12d
mov    %r12w,0x6(%rsp)
lea    0x6(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <gds_swap2bytes@plt>
mov    %r15d,%edi
mov    %rbx,%rsi
mov    $0x2,%edx
xor    %eax,%eax
call   1030 <write@plt>
movw   $0x206,0x4(%rsp)
lea    0x4(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <gds_swap2bytes@plt>
mov    %r15d,%edi
mov    %rbx,%rsi
mov    $0x2,%edx
xor    %eax,%eax
call   1030 <write@plt>
mov    0x2c5e(%rip),%rsi
mov    %r15d,%edi
mov    %ebp,%edx
xor    %eax,%eax
call   1030 <write@plt>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%r12w
jae    141b <gds_write_libname+0x2db>
xor    %edx,%edx
jmp    1501 <gds_write_libname+0x3c1>
mov    %r9d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
mov    %rbp,%rcx
cmp    $0x60,%rsi
jae    1444 <gds_write_libname+0x304>
xor    %esi,%esi
jmp    14b0 <gds_write_libname+0x370>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%rax,%rsi,1)
movups %xmm1,0x10(%rax,%rsi,1)
movups 0x20(%r14,%rsi,1),%xmm0
movups 0x30(%r14,%rsi,1),%xmm1
movups %xmm0,0x20(%rax,%rsi,1)
movups %xmm1,0x30(%rax,%rsi,1)
movups 0x40(%r14,%rsi,1),%xmm0
movups 0x50(%r14,%rsi,1),%xmm1
movups %xmm0,0x40(%rax,%rsi,1)
movups %xmm1,0x50(%rax,%rsi,1)
movups 0x60(%r14,%rsi,1),%xmm0
movups 0x70(%r14,%rsi,1),%xmm1
movups %xmm0,0x60(%rax,%rsi,1)
movups %xmm1,0x70(%rax,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1450 <gds_write_libname+0x310>
test   %r8,%r8
je     14eb <gds_write_libname+0x3ab>
lea    (%rax,%rsi,1),%rdi
add    $0x10,%rdi
add    %r14,%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    14d0 <gds_write_libname+0x390>
cmp    %r9,%rdx
mov    %rcx,%rbp
je     139c <gds_write_libname+0x25c>
test   $0x18,%r9b
je     11da <gds_write_libname+0x9a>
mov    %rdx,%rsi
mov    %r9d,%edx
and    $0xfffffff8,%edx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rsi,1),%rdi
mov    %rdi,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1510 <gds_write_libname+0x3d0>
cmp    %r9,%rdx
je     139c <gds_write_libname+0x25c>
jmp    11da <gds_write_libname+0x9a>

LLVM IR (-O0):
@gds_write_libname.pad = internal global i32 0
@gds_write_libname.ps = internal global i8* null
define void @gds_write_libname(i32 %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i16
%6 = alloca i16
%7 = alloca i16
%8 = alloca i16
store i32 %0, i32* %3
store i8* %1, i8** %4
%9 = load i8*, i8** %4
%10 = call signext i16 @strlen(i8* %9)
store i16 %10, i16* %6
%11 = load i16, i16* %6
%12 = sext i16 %11 to i32
%13 = srem i32 %12, 2
%14 = icmp ne i32 %13, 0
%15 = zext i1 %14 to i32
store i32 %15, i32* @gds_write_libname.pad
%16 = load i32, i32* @gds_write_libname.pad
%17 = icmp ne i32 %16, 0
br i1 %17, label %18, label %21
18: ; preds = %2
%19 = load i16, i16* %6
%20 = add i16 %19, 1
store i16 %20, i16* %6
br label %21
21: ; preds = %18, %2
%22 = load i16, i16* %6
%23 = call i64 @malloc(i16 signext %22)
%24 = inttoptr i64 %23 to i8*
store i8* %24, i8** @gds_write_libname.ps
%25 = load i32, i32* @gds_write_libname.pad
%26 = icmp ne i32 %25, 0
br i1 %26, label %27, label %55
27: ; preds = %21
store i16 0, i16* %7
br label %28
28: ; preds = %45, %27
%29 = load i16, i16* %7
%30 = sext i16 %29 to i32
%31 = load i16, i16* %6
%32 = sext i16 %31 to i32
%33 = sub nsw i32 %32, 1
%34 = icmp slt i32 %30, %33
br i1 %34, label %35, label %48
35: ; preds = %28
%36 = load i8*, i8** %4
%37 = load i16, i16* %7
%38 = sext i16 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
%40 = load i8, i8* %39
%41 = load i8*, i8** @gds_write_libname.ps
%42 = load i16, i16* %7
%43 = sext i16 %42 to i64
%44 = getelementptr inbounds i8, i8* %41, i64 %43
store i8 %40, i8* %44
br label %45
45: ; preds = %35
%46 = load i16, i16* %7
%47 = add i16 %46, 1
store i16 %47, i16* %7
br label %28
48: ; preds = %28
%49 = load i8*, i8** @gds_write_libname.ps
%50 = load i16, i16* %6
%51 = sext i16 %50 to i32
%52 = sub nsw i32 %51, 1
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %49, i64 %53
store i8 0, i8* %54
br label %76
55: ; preds = %21
store i16 0, i16* %7
br label %56
56: ; preds = %72, %55
%57 = load i16, i16* %7
%58 = sext i16 %57 to i32
%59 = load i16, i16* %6
%60 = sext i16 %59 to i32
%61 = icmp slt i32 %58, %60
br i1 %61, label %62, label %75
62: ; preds = %56
%63 = load i8*, i8** %4
%64 = load i16, i16* %7
%65 = sext i16 %64 to i64
%66 = getelementptr inbounds i8, i8* %63, i64 %65
%67 = load i8, i8* %66
%68 = load i8*, i8** @gds_write_libname.ps
%69 = load i16, i16* %7
%70 = sext i16 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
store i8 %67, i8* %71
br label %72
72: ; preds = %62
%73 = load i16, i16* %7
%74 = add i16 %73, 1
store i16 %74, i16* %7
br label %56
75: ; preds = %56
br label %76
76: ; preds = %75, %48
%77 = load i16, i16* %6
%78 = sext i16 %77 to i32
%79 = add nsw i32 4, %78
%80 = trunc i32 %79 to i16
store i16 %80, i16* %5
%81 = bitcast i16* %5 to i8*
%82 = call i32 @gds_swap2bytes(i8* %81)
%83 = load i32, i32* %3
%84 = call i32 (i32, ...) @write(i32 %83, i16* %5, i32 2)
store i16 518, i16* %8
%85 = bitcast i16* %8 to i8*
%86 = call i32 @gds_swap2bytes(i8* %85)
%87 = load i32, i32* %3
%88 = call i32 (i32, ...) @write(i32 %87, i16* %8, i32 2)
%89 = load i32, i32* %3
%90 = load i8*, i8** @gds_write_libname.ps
%91 = load i16, i16* %6
%92 = sext i16 %91 to i32
%93 = call i32 (i32, ...) @write(i32 %89, i8* %90, i32 %92)
ret void
}

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