#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 rand();
int /*<<< orphan*/ split_ip(char **, char *);
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
void create_uuid(char *uuid, char *timestamp, char *ip) {
  char octets[3][4];
  split_ip(octets, ip);
  char ip_part[13] = "000000000000";
  for (int i = 0; i < 4; ++i) {
    int olen = strlen(octets[i]);
    for (int j = 0; j < olen; ++j) {
      ip_part[i * 3 + (3 - olen) + j] = octets[i][j];
    }
  }
  char r_string[4];
  int rnum;
  srand(time(NULL));
  for (int i = 0; i < 3; ++i) {
    r_string[i] = rand() % 10 + 48;
  }
  strcpy(uuid, "");
  strcat(uuid, "I");
  strcat(uuid, ip_part);
  strcat(uuid, "T");
  strcat(uuid, timestamp);
  strcat(uuid, "R");
  strcat(uuid, r_string);
}


x86 assembly (clang, -O0):
<create_uuid>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x24(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1060 <split_ip@plt>
mov    0xe68(%rip),%rax
mov    %rax,-0x31(%rbp)
mov    0xe66(%rip),%eax
mov    %eax,-0x29(%rbp)
mov    0xe61(%rip),%al
mov    %al,-0x25(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x4,-0x38(%rbp)
jge    1237 <create_uuid+0xc7>
movslq -0x38(%rbp),%rax
lea    -0x24(%rbp),%rdi
shl    $0x2,%rax
add    %rax,%rdi
call   1040 <strlen@plt>
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1224 <create_uuid+0xb4>
movslq -0x38(%rbp),%rcx
lea    -0x24(%rbp),%rax
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
imul   $0x3,-0x38(%rbp),%eax
mov    $0x3,%edx
sub    -0x3c(%rbp),%edx
add    %edx,%eax
add    -0x40(%rbp),%eax
cltq
mov    %cl,-0x31(%rbp,%rax,1)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11dd <create_uuid+0x6d>
jmp    1229 <create_uuid+0xb9>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11b5 <create_uuid+0x45>
xor    %eax,%eax
mov    %eax,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1050 <srand@plt>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x3,-0x4c(%rbp)
jge    1282 <create_uuid+0x112>
mov    $0x0,%al
call   1090 <rand@plt>
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x4c(%rbp),%rax
mov    %cl,-0x44(%rbp,%rax,1)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    124e <create_uuid+0xde>
mov    -0x8(%rbp),%rdi
lea    0xd7f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%rdi
lea    0xd70(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x8(%rbp),%rdi
lea    -0x31(%rbp),%rsi
call   1080 <strcat@plt>
mov    -0x8(%rbp),%rdi
lea    0xd55(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1080 <strcat@plt>
mov    -0x8(%rbp),%rdi
lea    0xd3a(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x8(%rbp),%rdi
lea    -0x44(%rbp),%rsi
call   1080 <strcat@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<create_uuid>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rsi,%r14
mov    %rdi,%r15
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
mov    %rdx,%rsi
call   1060 <split_ip@plt>
movabs $0x30303030303030,%rax
mov    %rax,0x5(%rsp)
movabs $0x3030303030303030,%rax
30 30 30
mov    %rax,(%rsp)
mov    %rbx,%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1299 <create_uuid+0x129>
mov    %eax,%r8d
cmp    $0x8,%eax
jae    165e <create_uuid+0x4ee>
xor    %edx,%edx
mov    %rdx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rsi
and    $0x3,%rsi
je     1208 <create_uuid+0x98>
mov    $0x3,%edi
sub    %eax,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x10(%rsp,%rdx,1),%ebx
lea    (%rdi,%rdx,1),%ecx
movslq %ecx,%rcx
mov    %bl,(%rsp,%rcx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    11f0 <create_uuid+0x80>
cmp    $0x3,%r9
jb     1299 <create_uuid+0x129>
mov    $0x6,%r9d
sub    %eax,%r9d
lea    0x13(%rsp),%rdi
mov    $0x5,%ebx
sub    %eax,%ebx
mov    $0x3,%ecx
sub    %eax,%ecx
mov    $0x4,%esi
sub    %eax,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x3(%rdi,%rdx,1),%r10d
lea    (%rdx,%rcx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl -0x2(%rdi,%rdx,1),%r10d
lea    (%rsi,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl -0x1(%rdi,%rdx,1),%r10d
lea    (%rbx,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl (%rdi,%rdx,1),%r10d
lea    (%r9,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
add    $0xfffffffffffffffc,%r8
add    $0x4,%r9
add    $0x4,%rdi
add    $0x4,%rbx
add    $0x4,%rcx
add    $0x4,%rsi
cmp    %r8,%rdx
jne    1240 <create_uuid+0xd0>
lea    0x14(%rsp),%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1389 <create_uuid+0x219>
mov    %eax,%r8d
cmp    $0x8,%eax
jae    1694 <create_uuid+0x524>
xor    %edx,%edx
mov    %rdx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rsi
and    $0x3,%rsi
je     12f8 <create_uuid+0x188>
mov    $0x6,%edi
sub    %eax,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x14(%rsp,%rdx,1),%ebx
lea    (%rdi,%rdx,1),%ecx
movslq %ecx,%rcx
mov    %bl,(%rsp,%rcx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    12e0 <create_uuid+0x170>
cmp    $0x3,%r9
jb     1389 <create_uuid+0x219>
mov    $0x9,%r9d
sub    %eax,%r9d
lea    0x17(%rsp),%rdi
mov    $0x8,%ebx
sub    %eax,%ebx
mov    $0x7,%ecx
sub    %eax,%ecx
mov    $0x6,%esi
sub    %eax,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x3(%rdi,%rdx,1),%r10d
lea    (%rdx,%rsi,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl -0x2(%rdi,%rdx,1),%r10d
lea    (%rcx,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl -0x1(%rdi,%rdx,1),%r10d
lea    (%rbx,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl (%rdi,%rdx,1),%r10d
lea    (%r9,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
add    $0xfffffffffffffffc,%r8
add    $0x4,%r9
add    $0x4,%rdi
add    $0x4,%rbx
add    $0x4,%rcx
add    $0x4,%rsi
cmp    %r8,%rdx
jne    1330 <create_uuid+0x1c0>
lea    0x18(%rsp),%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1479 <create_uuid+0x309>
mov    %eax,%r8d
cmp    $0x8,%eax
jae    16ca <create_uuid+0x55a>
xor    %edx,%edx
mov    %rdx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rsi
and    $0x3,%rsi
je     13e8 <create_uuid+0x278>
mov    $0x9,%edi
sub    %eax,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x18(%rsp,%rdx,1),%ebx
lea    (%rdi,%rdx,1),%ecx
movslq %ecx,%rcx
mov    %bl,(%rsp,%rcx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    13d0 <create_uuid+0x260>
cmp    $0x3,%r9
jb     1479 <create_uuid+0x309>
mov    $0xc,%r9d
sub    %eax,%r9d
lea    0x1b(%rsp),%rdi
mov    $0xb,%ebx
sub    %eax,%ebx
mov    $0xa,%ecx
sub    %eax,%ecx
mov    $0x9,%esi
sub    %eax,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x3(%rdi,%rdx,1),%r10d
lea    (%rdx,%rsi,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl -0x2(%rdi,%rdx,1),%r10d
lea    (%rcx,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl -0x1(%rdi,%rdx,1),%r10d
lea    (%rbx,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl (%rdi,%rdx,1),%r10d
lea    (%r9,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
add    $0xfffffffffffffffc,%r8
add    $0x4,%r9
add    $0x4,%rdi
add    $0x4,%rbx
add    $0x4,%rcx
add    $0x4,%rsi
cmp    %r8,%rdx
jne    1420 <create_uuid+0x2b0>
lea    0x1c(%rsp),%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1569 <create_uuid+0x3f9>
mov    %eax,%r8d
cmp    $0x8,%eax
jae    1700 <create_uuid+0x590>
xor    %edx,%edx
mov    %rdx,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rsi
and    $0x3,%rsi
je     14d8 <create_uuid+0x368>
mov    $0xc,%edi
sub    %eax,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x1c(%rsp,%rdx,1),%ebx
lea    (%rdi,%rdx,1),%ecx
movslq %ecx,%rcx
mov    %bl,(%rsp,%rcx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    14c0 <create_uuid+0x350>
cmp    $0x3,%r9
jb     1569 <create_uuid+0x3f9>
mov    $0xf,%r9d
sub    %eax,%r9d
lea    0x1f(%rsp),%rdi
mov    $0xe,%ebx
sub    %eax,%ebx
mov    $0xd,%ecx
sub    %eax,%ecx
mov    $0xc,%esi
sub    %eax,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x3(%rdi,%rdx,1),%r10d
lea    (%rdx,%rsi,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl -0x2(%rdi,%rdx,1),%r10d
lea    (%rcx,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl -0x1(%rdi,%rdx,1),%r10d
lea    (%rbx,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
movzbl (%rdi,%rdx,1),%r10d
lea    (%r9,%rdx,1),%eax
cltq
mov    %r10b,(%rsp,%rax,1)
add    $0xfffffffffffffffc,%r8
add    $0x4,%r9
add    $0x4,%rdi
add    $0x4,%rbx
add    $0x4,%rcx
add    $0x4,%rsi
cmp    %r8,%rdx
jne    1510 <create_uuid+0x3a0>
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1050 <srand@plt>
xor    %eax,%eax
call   1090 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x1c(%rsp)
xor    %eax,%eax
call   1090 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x1d(%rsp)
xor    %eax,%eax
call   1090 <rand@plt>
cltq
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
add    $0x30,%al
mov    %al,0x1e(%rsp)
lea    0xa10(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xa02(%rip),%rsi
mov    %r15,%rdi
call   1080 <strcat@plt>
mov    %rsp,%rsi
mov    %r15,%rdi
call   1080 <strcat@plt>
lea    0x9ea(%rip),%rsi
mov    %r15,%rdi
call   1080 <strcat@plt>
mov    %r15,%rdi
mov    %r14,%rsi
call   1080 <strcat@plt>
lea    0x9d2(%rip),%rsi
mov    %r15,%rdi
call   1080 <strcat@plt>
lea    0x1c(%rsp),%rsi
mov    %r15,%rdi
call   1080 <strcat@plt>
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret
mov    $0x3,%r10d
sub    %eax,%r10d
lea    -0x1(%r8),%rcx
lea    (%rcx,%r10,1),%edi
xor    %edx,%edx
cmp    %r10d,%edi
jl     11ca <create_uuid+0x5a>
shr    $0x20,%rcx
jne    11ca <create_uuid+0x5a>
cmp    $0x20,%eax
jae    1736 <create_uuid+0x5c6>
xor    %edx,%edx
jmp    17de <create_uuid+0x66e>
mov    $0x6,%r10d
sub    %eax,%r10d
lea    -0x1(%r8),%rcx
lea    (%rcx,%r10,1),%edi
xor    %edx,%edx
cmp    %r10d,%edi
jl     12b9 <create_uuid+0x149>
shr    $0x20,%rcx
jne    12b9 <create_uuid+0x149>
cmp    $0x20,%eax
jae    1816 <create_uuid+0x6a6>
xor    %edx,%edx
jmp    18be <create_uuid+0x74e>
mov    $0x9,%r10d
sub    %eax,%r10d
lea    -0x1(%r8),%rcx
lea    (%rcx,%r10,1),%edi
xor    %edx,%edx
cmp    %r10d,%edi
jl     13a9 <create_uuid+0x239>
shr    $0x20,%rcx
jne    13a9 <create_uuid+0x239>
cmp    $0x20,%eax
jae    18f6 <create_uuid+0x786>
xor    %edx,%edx
jmp    199e <create_uuid+0x82e>
mov    $0xc,%r10d
sub    %eax,%r10d
lea    -0x1(%r8),%rcx
lea    (%rcx,%r10,1),%edi
xor    %edx,%edx
cmp    %r10d,%edi
jl     1499 <create_uuid+0x329>
shr    $0x20,%rcx
jne    1499 <create_uuid+0x329>
cmp    $0x20,%eax
jae    19d6 <create_uuid+0x866>
xor    %edx,%edx
jmp    1a7e <create_uuid+0x90e>
mov    %r8d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1ab6 <create_uuid+0x946>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    $0x23,%ebx
sub    %eax,%ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x20(%rbx),%esi
movslq %esi,%rsi
movups 0x10(%rsp,%rdi,1),%xmm0
movups 0x20(%rsp,%rdi,1),%xmm1
movups 0x30(%rsp,%rdi,1),%xmm2
movups 0x40(%rsp,%rdi,1),%xmm3
movups %xmm0,(%rsp,%rsi,1)
movups %xmm1,0x10(%rsp,%rsi,1)
movslq %ebx,%rbx
movups %xmm2,(%rsp,%rbx,1)
movups %xmm3,0x10(%rsp,%rbx,1)
add    $0x40,%rdi
add    $0x40,%ebx
add    $0xfffffffffffffffe,%rcx
jne    1770 <create_uuid+0x600>
test   $0x1,%r9b
je     17cb <create_uuid+0x65b>
movups 0x10(%rsp,%rdi,1),%xmm0
movups 0x20(%rsp,%rdi,1),%xmm1
add    %edi,%r10d
movslq %r10d,%rcx
movups %xmm0,(%rsp,%rcx,1)
movups %xmm1,0x10(%rsp,%rcx,1)
cmp    %r8,%rdx
je     1299 <create_uuid+0x129>
test   $0x18,%r8b
je     11ca <create_uuid+0x5a>
mov    %rdx,%rcx
mov    %r8d,%edx
and    $0xfffffff8,%edx
mov    $0x3,%esi
sub    %eax,%esi
xchg   %ax,%ax
mov    0x10(%rsp,%rcx,1),%rdi
lea    (%rsi,%rcx,1),%ebx
movslq %ebx,%rbx
mov    %rdi,(%rsp,%rbx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    17f0 <create_uuid+0x680>
cmp    %r8,%rdx
jne    11ca <create_uuid+0x5a>
jmp    1299 <create_uuid+0x129>
mov    %r8d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1ac7 <create_uuid+0x957>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    $0x26,%ebx
sub    %eax,%ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x20(%rbx),%esi
movslq %esi,%rsi
movups 0x14(%rsp,%rdi,1),%xmm0
movups 0x24(%rsp,%rdi,1),%xmm1
movups 0x34(%rsp,%rdi,1),%xmm2
movups 0x44(%rsp,%rdi,1),%xmm3
movups %xmm0,(%rsp,%rsi,1)
movups %xmm1,0x10(%rsp,%rsi,1)
movslq %ebx,%rbx
movups %xmm2,(%rsp,%rbx,1)
movups %xmm3,0x10(%rsp,%rbx,1)
add    $0x40,%rdi
add    $0x40,%ebx
add    $0xfffffffffffffffe,%rcx
jne    1850 <create_uuid+0x6e0>
test   $0x1,%r9b
je     18ab <create_uuid+0x73b>
movups 0x14(%rsp,%rdi,1),%xmm0
movups 0x24(%rsp,%rdi,1),%xmm1
add    %edi,%r10d
movslq %r10d,%rcx
movups %xmm0,(%rsp,%rcx,1)
movups %xmm1,0x10(%rsp,%rcx,1)
cmp    %r8,%rdx
je     1389 <create_uuid+0x219>
test   $0x18,%r8b
je     12b9 <create_uuid+0x149>
mov    %rdx,%rcx
mov    %r8d,%edx
and    $0xfffffff8,%edx
mov    $0x6,%esi
sub    %eax,%esi
xchg   %ax,%ax
mov    0x14(%rsp,%rcx,1),%rdi
lea    (%rsi,%rcx,1),%ebx
movslq %ebx,%rbx
mov    %rdi,(%rsp,%rbx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    18d0 <create_uuid+0x760>
cmp    %r8,%rdx
jne    12b9 <create_uuid+0x149>
jmp    1389 <create_uuid+0x219>
mov    %r8d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1ad8 <create_uuid+0x968>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    $0x29,%ebx
sub    %eax,%ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x20(%rbx),%esi
movslq %esi,%rsi
movups 0x18(%rsp,%rdi,1),%xmm0
movups 0x28(%rsp,%rdi,1),%xmm1
movups 0x38(%rsp,%rdi,1),%xmm2
movups 0x48(%rsp,%rdi,1),%xmm3
movups %xmm0,(%rsp,%rsi,1)
movups %xmm1,0x10(%rsp,%rsi,1)
movslq %ebx,%rbx
movups %xmm2,(%rsp,%rbx,1)
movups %xmm3,0x10(%rsp,%rbx,1)
add    $0x40,%rdi
add    $0x40,%ebx
add    $0xfffffffffffffffe,%rcx
jne    1930 <create_uuid+0x7c0>
test   $0x1,%r9b
je     198b <create_uuid+0x81b>
movups 0x18(%rsp,%rdi,1),%xmm0
movups 0x28(%rsp,%rdi,1),%xmm1
add    %edi,%r10d
movslq %r10d,%rcx
movups %xmm0,(%rsp,%rcx,1)
movups %xmm1,0x10(%rsp,%rcx,1)
cmp    %r8,%rdx
je     1479 <create_uuid+0x309>
test   $0x18,%r8b
je     13a9 <create_uuid+0x239>
mov    %rdx,%rcx
mov    %r8d,%edx
and    $0xfffffff8,%edx
mov    $0x9,%esi
sub    %eax,%esi
xchg   %ax,%ax
mov    0x18(%rsp,%rcx,1),%rdi
lea    (%rsi,%rcx,1),%ebx
movslq %ebx,%rbx
mov    %rdi,(%rsp,%rbx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    19b0 <create_uuid+0x840>
cmp    %r8,%rdx
jne    13a9 <create_uuid+0x239>
jmp    1479 <create_uuid+0x309>
mov    %r8d,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rcx
mov    %rcx,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1ae9 <create_uuid+0x979>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    $0x2c,%ebx
sub    %eax,%ebx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x20(%rbx),%esi
movslq %esi,%rsi
movups 0x1c(%rsp,%rdi,1),%xmm0
movups 0x2c(%rsp,%rdi,1),%xmm1
movups 0x3c(%rsp,%rdi,1),%xmm2
movups 0x4c(%rsp,%rdi,1),%xmm3
movups %xmm0,(%rsp,%rsi,1)
movups %xmm1,0x10(%rsp,%rsi,1)
movslq %ebx,%rbx
movups %xmm2,(%rsp,%rbx,1)
movups %xmm3,0x10(%rsp,%rbx,1)
add    $0x40,%rdi
add    $0x40,%ebx
add    $0xfffffffffffffffe,%rcx
jne    1a10 <create_uuid+0x8a0>
test   $0x1,%r9b
je     1a6b <create_uuid+0x8fb>
movups 0x1c(%rsp,%rdi,1),%xmm0
movups 0x2c(%rsp,%rdi,1),%xmm1
add    %edi,%r10d
movslq %r10d,%rcx
movups %xmm0,(%rsp,%rcx,1)
movups %xmm1,0x10(%rsp,%rcx,1)
cmp    %r8,%rdx
je     1569 <create_uuid+0x3f9>
test   $0x18,%r8b
je     1499 <create_uuid+0x329>
mov    %rdx,%rcx
mov    %r8d,%edx
and    $0xfffffff8,%edx
mov    $0xc,%esi
sub    %eax,%esi
xchg   %ax,%ax
mov    0x1c(%rsp,%rcx,1),%rdi
lea    (%rsi,%rcx,1),%ebx
movslq %ebx,%rbx
mov    %rdi,(%rsp,%rbx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1a90 <create_uuid+0x920>
cmp    %r8,%rdx
jne    1499 <create_uuid+0x329>
jmp    1569 <create_uuid+0x3f9>
xor    %edi,%edi
test   $0x1,%r9b
jne    17b2 <create_uuid+0x642>
jmp    17cb <create_uuid+0x65b>
xor    %edi,%edi
test   $0x1,%r9b
jne    1892 <create_uuid+0x722>
jmp    18ab <create_uuid+0x73b>
xor    %edi,%edi
test   $0x1,%r9b
jne    1972 <create_uuid+0x802>
jmp    198b <create_uuid+0x81b>
xor    %edi,%edi
test   $0x1,%r9b
jne    1a52 <create_uuid+0x8e2>
jmp    1a6b <create_uuid+0x8fb>

LLVM IR (-O0):
@__const.create_uuid.ip_part = [13 x i8] c"000000000000\00"
@.str = [1 x i8] zeroinitializer
@.str.1 = [2 x i8] c"I\00"
@.str.2 = [2 x i8] c"T\00"
@.str.3 = [2 x i8] c"R\00"
define void @create_uuid(i8* %0, i8* %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca [3 x [4 x i8]]
%8 = alloca [13 x i8]
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca [4 x i8]
%13 = alloca i32
%14 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* %2, i8** %6
%15 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %7, i64 0, i64 0
%16 = bitcast [4 x i8]* %15 to i8**
%17 = load i8*, i8** %6
%18 = call i32 @split_ip(i8** %16, i8* %17)
%19 = bitcast [13 x i8]* %8 to i8*
store i32 0, i32* %9
br label %20
20: ; preds = %54, %3
%21 = load i32, i32* %9
%22 = icmp slt i32 %21, 4
br i1 %22, label %23, label %57
23: ; preds = %20
%24 = load i32, i32* %9
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %7, i64 0, i64 %25
%27 = getelementptr inbounds [4 x i8], [4 x i8]* %26, i64 0, i64 0
%28 = call i32 @strlen(i8* %27)
store i32 %28, i32* %10
store i32 0, i32* %11
br label %29
29: ; preds = %50, %23
%30 = load i32, i32* %11
%31 = load i32, i32* %10
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %53
33: ; preds = %29
%34 = load i32, i32* %9
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %7, i64 0, i64 %35
%37 = load i32, i32* %11
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [4 x i8], [4 x i8]* %36, i64 0, i64 %38
%40 = load i8, i8* %39
%41 = load i32, i32* %9
%42 = mul nsw i32 %41, 3
%43 = load i32, i32* %10
%44 = sub nsw i32 3, %43
%45 = add nsw i32 %42, %44
%46 = load i32, i32* %11
%47 = add nsw i32 %45, %46
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [13 x i8], [13 x i8]* %8, i64 0, i64 %48
store i8 %40, i8* %49
br label %50
50: ; preds = %33
%51 = load i32, i32* %11
%52 = add nsw i32 %51, 1
store i32 %52, i32* %11
br label %29
53: ; preds = %29
br label %54
54: ; preds = %53
%55 = load i32, i32* %9
%56 = add nsw i32 %55, 1
store i32 %56, i32* %9
br label %20
57: ; preds = %20
%58 = call i32 @time(i32* null)
%59 = call i32 @srand(i32 %58)
store i32 0, i32* %14
br label %60
60: ; preds = %71, %57
%61 = load i32, i32* %14
%62 = icmp slt i32 %61, 3
br i1 %62, label %63, label %74
63: ; preds = %60
%64 = call i32 (...) @rand()
%65 = srem i32 %64, 10
%66 = add nsw i32 %65, 48
%67 = trunc i32 %66 to i8
%68 = load i32, i32* %14
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 %69
store i8 %67, i8* %70
br label %71
71: ; preds = %63
%72 = load i32, i32* %14
%73 = add nsw i32 %72, 1
store i32 %73, i32* %14
br label %60
74: ; preds = %60
%75 = load i8*, i8** %4
%76 = call i32 @strcpy(i8* %75, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%77 = load i8*, i8** %4
%78 = call i32 @strcat(i8* %77, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%79 = load i8*, i8** %4
%80 = getelementptr inbounds [13 x i8], [13 x i8]* %8, i64 0, i64 0
%81 = call i32 @strcat(i8* %79, i8* %80)
%82 = load i8*, i8** %4
%83 = call i32 @strcat(i8* %82, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%84 = load i8*, i8** %4
%85 = load i8*, i8** %5
%86 = call i32 @strcat(i8* %84, i8* %85)
%87 = load i8*, i8** %4
%88 = call i32 @strcat(i8* %87, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%89 = load i8*, i8** %4
%90 = getelementptr inbounds [4 x i8], [4 x i8]* %12, i64 0, i64 0
%91 = call i32 @strcat(i8* %89, i8* %90)
ret void
}

LLVM IR (-O2):
@__const.create_uuid.ip_part = [13 x i8] c"000000000000\00"
@.str = [1 x i8] zeroinitializer
@.str.1 = [2 x i8] c"I\00"
@.str.2 = [2 x i8] c"T\00"
@.str.3 = [2 x i8] c"R\00"
define void @create_uuid(i8* %0, i8* %1, i8* %2) {
%4 = alloca [3 x [4 x i8]]
%5 = alloca [13 x i8]
%6 = alloca [4 x i8]
%7 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 0
%8 = bitcast [3 x [4 x i8]]* %4 to i8**
%9 = call i32 @split_ip(i8** %8, i8* %2)
%10 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 0
%11 = call i32 @strlen(i8* %7)
%12 = icmp sgt i32 %11, 0
br i1 %12, label %13, label %129
13: ; preds = %3
%14 = sub nsw i32 3, %11
%15 = zext i32 %11 to i64
%16 = icmp ult i32 %11, 8
br i1 %16, label %108, label %17
17: ; preds = %13
%18 = add nsw i64 %15, -1
%19 = sub i32 3, %11
%20 = trunc i64 %18 to i32
%21 = add i32 %19, %20
%22 = icmp slt i32 %21, %19
%23 = icmp ugt i64 %18, 4294967295
%24 = or i1 %22, %23
br i1 %24, label %108, label %25
25: ; preds = %17
%26 = icmp ult i32 %11, 32
br i1 %26, label %91, label %27
27: ; preds = %25
%28 = and i64 %15, 4294967264
%29 = add nsw i64 %28, -32
%30 = lshr exact i64 %29, 5
%31 = add nuw nsw i64 %30, 1
%32 = and i64 %31, 1
%33 = icmp eq i64 %29, 0
br i1 %33, label %69, label %34
34: ; preds = %27
%35 = and i64 %31, 1152921504606846974
br label %36
36: ; preds = %36, %34
%37 = phi i64 [ 0, %34 ], [ %66, %36 ]
%38 = phi i64 [ 0, %34 ], [ %67, %36 ]
%39 = trunc i64 %37 to i32
%40 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %37
%41 = bitcast i8* %40 to <16 x i8>*
%42 = load <16 x i8>, <16 x i8>* %41
%43 = getelementptr inbounds i8, i8* %40, i64 16
%44 = bitcast i8* %43 to <16 x i8>*
%45 = load <16 x i8>, <16 x i8>* %44
%46 = add i32 %14, %39
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %47
%49 = bitcast i8* %48 to <16 x i8>*
store <16 x i8> %42, <16 x i8>* %49
%50 = getelementptr inbounds i8, i8* %48, i64 16
%51 = bitcast i8* %50 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %51
%52 = or i64 %37, 32
%53 = trunc i64 %52 to i32
%54 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %52
%55 = bitcast i8* %54 to <16 x i8>*
%56 = load <16 x i8>, <16 x i8>* %55
%57 = getelementptr inbounds i8, i8* %54, i64 16
%58 = bitcast i8* %57 to <16 x i8>*
%59 = load <16 x i8>, <16 x i8>* %58
%60 = add i32 %14, %53
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %61
%63 = bitcast i8* %62 to <16 x i8>*
store <16 x i8> %56, <16 x i8>* %63
%64 = getelementptr inbounds i8, i8* %62, i64 16
%65 = bitcast i8* %64 to <16 x i8>*
store <16 x i8> %59, <16 x i8>* %65
%66 = add nuw i64 %37, 64
%67 = add i64 %38, 2
%68 = icmp eq i64 %67, %35
br i1 %68, label %69, label %36
69: ; preds = %36, %27
%70 = phi i64 [ 0, %27 ], [ %66, %36 ]
%71 = icmp eq i64 %32, 0
br i1 %71, label %86, label %72
72: ; preds = %69
%73 = trunc i64 %70 to i32
%74 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %70
%75 = bitcast i8* %74 to <16 x i8>*
%76 = load <16 x i8>, <16 x i8>* %75
%77 = getelementptr inbounds i8, i8* %74, i64 16
%78 = bitcast i8* %77 to <16 x i8>*
%79 = load <16 x i8>, <16 x i8>* %78
%80 = add i32 %14, %73
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %81
%83 = bitcast i8* %82 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %83
%84 = getelementptr inbounds i8, i8* %82, i64 16
%85 = bitcast i8* %84 to <16 x i8>*
store <16 x i8> %79, <16 x i8>* %85
br label %86
86: ; preds = %69, %72
%87 = icmp eq i64 %28, %15
br i1 %87, label %129, label %88
88: ; preds = %86
%89 = and i64 %15, 24
%90 = icmp eq i64 %89, 0
br i1 %90, label %108, label %91
91: ; preds = %25, %88
%92 = phi i64 [ %28, %88 ], [ 0, %25 ]
%93 = and i64 %15, 4294967288
br label %94
94: ; preds = %94, %91
%95 = phi i64 [ %92, %91 ], [ %104, %94 ]
%96 = trunc i64 %95 to i32
%97 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %95
%98 = bitcast i8* %97 to <8 x i8>*
%99 = load <8 x i8>, <8 x i8>* %98
%100 = add i32 %14, %96
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %101
%103 = bitcast i8* %102 to <8 x i8>*
store <8 x i8> %99, <8 x i8>* %103
%104 = add nuw i64 %95, 8
%105 = icmp eq i64 %104, %93
br i1 %105, label %106, label %94
106: ; preds = %94
%107 = icmp eq i64 %93, %15
br i1 %107, label %129, label %108
108: ; preds = %17, %13, %88, %106
%109 = phi i64 [ 0, %13 ], [ 0, %17 ], [ %28, %88 ], [ %93, %106 ]
%110 = xor i64 %109, -1
%111 = add nsw i64 %110, %15
%112 = and i64 %15, 3
%113 = icmp eq i64 %112, 0
br i1 %113, label %126, label %114
114: ; preds = %108, %114
%115 = phi i64 [ %123, %114 ], [ %109, %108 ]
%116 = phi i64 [ %124, %114 ], [ 0, %108 ]
%117 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %115
%118 = load i8, i8* %117
%119 = trunc i64 %115 to i32
%120 = add i32 %14, %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %121
store i8 %118, i8* %122
%123 = add nuw nsw i64 %115, 1
%124 = add i64 %116, 1
%125 = icmp eq i64 %124, %112
br i1 %125, label %126, label %114
126: ; preds = %114, %108
%127 = phi i64 [ %109, %108 ], [ %123, %114 ]
%128 = icmp ult i64 %111, 3
br i1 %128, label %129, label %607
129: ; preds = %126, %607, %86, %106, %3
%130 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 0
%131 = call i32 @strlen(i8* %130)
%132 = icmp sgt i32 %131, 0
br i1 %132, label %133, label %280
133: ; preds = %129
%134 = sub nsw i32 6, %131
%135 = zext i32 %131 to i64
%136 = icmp ult i32 %131, 8
br i1 %136, label %228, label %137
137: ; preds = %133
%138 = add nsw i64 %135, -1
%139 = sub i32 6, %131
%140 = trunc i64 %138 to i32
%141 = add i32 %139, %140
%142 = icmp slt i32 %141, %139
%143 = icmp ugt i64 %138, 4294967295
%144 = or i1 %142, %143
br i1 %144, label %228, label %145
145: ; preds = %137
%146 = icmp ult i32 %131, 32
br i1 %146, label %211, label %147
147: ; preds = %145
%148 = and i64 %135, 4294967264
%149 = add nsw i64 %148, -32
%150 = lshr exact i64 %149, 5
%151 = add nuw nsw i64 %150, 1
%152 = and i64 %151, 1
%153 = icmp eq i64 %149, 0
br i1 %153, label %189, label %154
154: ; preds = %147
%155 = and i64 %151, 1152921504606846974
br label %156
156: ; preds = %156, %154
%157 = phi i64 [ 0, %154 ], [ %186, %156 ]
%158 = phi i64 [ 0, %154 ], [ %187, %156 ]
%159 = trunc i64 %157 to i32
%160 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %157
%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 = add i32 %134, %159
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %167
%169 = bitcast i8* %168 to <16 x i8>*
store <16 x i8> %162, <16 x i8>* %169
%170 = getelementptr inbounds i8, i8* %168, i64 16
%171 = bitcast i8* %170 to <16 x i8>*
store <16 x i8> %165, <16 x i8>* %171
%172 = or i64 %157, 32
%173 = trunc i64 %172 to i32
%174 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %172
%175 = bitcast i8* %174 to <16 x i8>*
%176 = load <16 x i8>, <16 x i8>* %175
%177 = getelementptr inbounds i8, i8* %174, i64 16
%178 = bitcast i8* %177 to <16 x i8>*
%179 = load <16 x i8>, <16 x i8>* %178
%180 = add i32 %134, %173
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %181
%183 = bitcast i8* %182 to <16 x i8>*
store <16 x i8> %176, <16 x i8>* %183
%184 = getelementptr inbounds i8, i8* %182, i64 16
%185 = bitcast i8* %184 to <16 x i8>*
store <16 x i8> %179, <16 x i8>* %185
%186 = add nuw i64 %157, 64
%187 = add i64 %158, 2
%188 = icmp eq i64 %187, %155
br i1 %188, label %189, label %156
189: ; preds = %156, %147
%190 = phi i64 [ 0, %147 ], [ %186, %156 ]
%191 = icmp eq i64 %152, 0
br i1 %191, label %206, label %192
192: ; preds = %189
%193 = trunc i64 %190 to i32
%194 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %190
%195 = bitcast i8* %194 to <16 x i8>*
%196 = load <16 x i8>, <16 x i8>* %195
%197 = getelementptr inbounds i8, i8* %194, i64 16
%198 = bitcast i8* %197 to <16 x i8>*
%199 = load <16 x i8>, <16 x i8>* %198
%200 = add i32 %134, %193
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %201
%203 = bitcast i8* %202 to <16 x i8>*
store <16 x i8> %196, <16 x i8>* %203
%204 = getelementptr inbounds i8, i8* %202, i64 16
%205 = bitcast i8* %204 to <16 x i8>*
store <16 x i8> %199, <16 x i8>* %205
br label %206
206: ; preds = %189, %192
%207 = icmp eq i64 %148, %135
br i1 %207, label %280, label %208
208: ; preds = %206
%209 = and i64 %135, 24
%210 = icmp eq i64 %209, 0
br i1 %210, label %228, label %211
211: ; preds = %145, %208
%212 = phi i64 [ %148, %208 ], [ 0, %145 ]
%213 = and i64 %135, 4294967288
br label %214
214: ; preds = %214, %211
%215 = phi i64 [ %212, %211 ], [ %224, %214 ]
%216 = trunc i64 %215 to i32
%217 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %215
%218 = bitcast i8* %217 to <8 x i8>*
%219 = load <8 x i8>, <8 x i8>* %218
%220 = add i32 %134, %216
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %221
%223 = bitcast i8* %222 to <8 x i8>*
store <8 x i8> %219, <8 x i8>* %223
%224 = add nuw i64 %215, 8
%225 = icmp eq i64 %224, %213
br i1 %225, label %226, label %214
226: ; preds = %214
%227 = icmp eq i64 %213, %135
br i1 %227, label %280, label %228
228: ; preds = %137, %133, %208, %226
%229 = phi i64 [ 0, %133 ], [ 0, %137 ], [ %148, %208 ], [ %213, %226 ]
%230 = xor i64 %229, -1
%231 = add nsw i64 %230, %135
%232 = and i64 %135, 3
%233 = icmp eq i64 %232, 0
br i1 %233, label %246, label %234
234: ; preds = %228, %234
%235 = phi i64 [ %243, %234 ], [ %229, %228 ]
%236 = phi i64 [ %244, %234 ], [ 0, %228 ]
%237 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %235
%238 = load i8, i8* %237
%239 = trunc i64 %235 to i32
%240 = add i32 %134, %239
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %241
store i8 %238, i8* %242
%243 = add nuw nsw i64 %235, 1
%244 = add i64 %236, 1
%245 = icmp eq i64 %244, %232
br i1 %245, label %246, label %234
246: ; preds = %234, %228
%247 = phi i64 [ %229, %228 ], [ %243, %234 ]
%248 = icmp ult i64 %231, 3
br i1 %248, label %280, label %249
249: ; preds = %246, %249
%250 = phi i64 [ %278, %249 ], [ %247, %246 ]
%251 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %250
%252 = load i8, i8* %251
%253 = trunc i64 %250 to i32
%254 = add i32 %134, %253
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %255
store i8 %252, i8* %256
%257 = add nuw nsw i64 %250, 1
%258 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %257
%259 = load i8, i8* %258
%260 = trunc i64 %257 to i32
%261 = add i32 %134, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %262
store i8 %259, i8* %263
%264 = add nuw nsw i64 %250, 2
%265 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %264
%266 = load i8, i8* %265
%267 = trunc i64 %264 to i32
%268 = add i32 %134, %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %269
store i8 %266, i8* %270
%271 = add nuw nsw i64 %250, 3
%272 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 1, i64 %271
%273 = load i8, i8* %272
%274 = trunc i64 %271 to i32
%275 = add i32 %134, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %276
store i8 %273, i8* %277
%278 = add nuw nsw i64 %250, 4
%279 = icmp eq i64 %278, %135
br i1 %279, label %280, label %249
280: ; preds = %246, %249, %206, %226, %129
%281 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 0
%282 = call i32 @strlen(i8* %281)
%283 = icmp sgt i32 %282, 0
br i1 %283, label %284, label %431
284: ; preds = %280
%285 = sub nsw i32 9, %282
%286 = zext i32 %282 to i64
%287 = icmp ult i32 %282, 8
br i1 %287, label %379, label %288
288: ; preds = %284
%289 = add nsw i64 %286, -1
%290 = sub i32 9, %282
%291 = trunc i64 %289 to i32
%292 = add i32 %290, %291
%293 = icmp slt i32 %292, %290
%294 = icmp ugt i64 %289, 4294967295
%295 = or i1 %293, %294
br i1 %295, label %379, label %296
296: ; preds = %288
%297 = icmp ult i32 %282, 32
br i1 %297, label %362, label %298
298: ; preds = %296
%299 = and i64 %286, 4294967264
%300 = add nsw i64 %299, -32
%301 = lshr exact i64 %300, 5
%302 = add nuw nsw i64 %301, 1
%303 = and i64 %302, 1
%304 = icmp eq i64 %300, 0
br i1 %304, label %340, label %305
305: ; preds = %298
%306 = and i64 %302, 1152921504606846974
br label %307
307: ; preds = %307, %305
%308 = phi i64 [ 0, %305 ], [ %337, %307 ]
%309 = phi i64 [ 0, %305 ], [ %338, %307 ]
%310 = trunc i64 %308 to i32
%311 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %308
%312 = bitcast i8* %311 to <16 x i8>*
%313 = load <16 x i8>, <16 x i8>* %312
%314 = getelementptr inbounds i8, i8* %311, i64 16
%315 = bitcast i8* %314 to <16 x i8>*
%316 = load <16 x i8>, <16 x i8>* %315
%317 = add i32 %285, %310
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %318
%320 = bitcast i8* %319 to <16 x i8>*
store <16 x i8> %313, <16 x i8>* %320
%321 = getelementptr inbounds i8, i8* %319, i64 16
%322 = bitcast i8* %321 to <16 x i8>*
store <16 x i8> %316, <16 x i8>* %322
%323 = or i64 %308, 32
%324 = trunc i64 %323 to i32
%325 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %323
%326 = bitcast i8* %325 to <16 x i8>*
%327 = load <16 x i8>, <16 x i8>* %326
%328 = getelementptr inbounds i8, i8* %325, i64 16
%329 = bitcast i8* %328 to <16 x i8>*
%330 = load <16 x i8>, <16 x i8>* %329
%331 = add i32 %285, %324
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %332
%334 = bitcast i8* %333 to <16 x i8>*
store <16 x i8> %327, <16 x i8>* %334
%335 = getelementptr inbounds i8, i8* %333, i64 16
%336 = bitcast i8* %335 to <16 x i8>*
store <16 x i8> %330, <16 x i8>* %336
%337 = add nuw i64 %308, 64
%338 = add i64 %309, 2
%339 = icmp eq i64 %338, %306
br i1 %339, label %340, label %307
340: ; preds = %307, %298
%341 = phi i64 [ 0, %298 ], [ %337, %307 ]
%342 = icmp eq i64 %303, 0
br i1 %342, label %357, label %343
343: ; preds = %340
%344 = trunc i64 %341 to i32
%345 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %341
%346 = bitcast i8* %345 to <16 x i8>*
%347 = load <16 x i8>, <16 x i8>* %346
%348 = getelementptr inbounds i8, i8* %345, i64 16
%349 = bitcast i8* %348 to <16 x i8>*
%350 = load <16 x i8>, <16 x i8>* %349
%351 = add i32 %285, %344
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %352
%354 = bitcast i8* %353 to <16 x i8>*
store <16 x i8> %347, <16 x i8>* %354
%355 = getelementptr inbounds i8, i8* %353, i64 16
%356 = bitcast i8* %355 to <16 x i8>*
store <16 x i8> %350, <16 x i8>* %356
br label %357
357: ; preds = %340, %343
%358 = icmp eq i64 %299, %286
br i1 %358, label %431, label %359
359: ; preds = %357
%360 = and i64 %286, 24
%361 = icmp eq i64 %360, 0
br i1 %361, label %379, label %362
362: ; preds = %296, %359
%363 = phi i64 [ %299, %359 ], [ 0, %296 ]
%364 = and i64 %286, 4294967288
br label %365
365: ; preds = %365, %362
%366 = phi i64 [ %363, %362 ], [ %375, %365 ]
%367 = trunc i64 %366 to i32
%368 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %366
%369 = bitcast i8* %368 to <8 x i8>*
%370 = load <8 x i8>, <8 x i8>* %369
%371 = add i32 %285, %367
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %372
%374 = bitcast i8* %373 to <8 x i8>*
store <8 x i8> %370, <8 x i8>* %374
%375 = add nuw i64 %366, 8
%376 = icmp eq i64 %375, %364
br i1 %376, label %377, label %365
377: ; preds = %365
%378 = icmp eq i64 %364, %286
br i1 %378, label %431, label %379
379: ; preds = %288, %284, %359, %377
%380 = phi i64 [ 0, %284 ], [ 0, %288 ], [ %299, %359 ], [ %364, %377 ]
%381 = xor i64 %380, -1
%382 = add nsw i64 %381, %286
%383 = and i64 %286, 3
%384 = icmp eq i64 %383, 0
br i1 %384, label %397, label %385
385: ; preds = %379, %385
%386 = phi i64 [ %394, %385 ], [ %380, %379 ]
%387 = phi i64 [ %395, %385 ], [ 0, %379 ]
%388 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %386
%389 = load i8, i8* %388
%390 = trunc i64 %386 to i32
%391 = add i32 %285, %390
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %392
store i8 %389, i8* %393
%394 = add nuw nsw i64 %386, 1
%395 = add i64 %387, 1
%396 = icmp eq i64 %395, %383
br i1 %396, label %397, label %385
397: ; preds = %385, %379
%398 = phi i64 [ %380, %379 ], [ %394, %385 ]
%399 = icmp ult i64 %382, 3
br i1 %399, label %431, label %400
400: ; preds = %397, %400
%401 = phi i64 [ %429, %400 ], [ %398, %397 ]
%402 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %401
%403 = load i8, i8* %402
%404 = trunc i64 %401 to i32
%405 = add i32 %285, %404
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %406
store i8 %403, i8* %407
%408 = add nuw nsw i64 %401, 1
%409 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %408
%410 = load i8, i8* %409
%411 = trunc i64 %408 to i32
%412 = add i32 %285, %411
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %413
store i8 %410, i8* %414
%415 = add nuw nsw i64 %401, 2
%416 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %415
%417 = load i8, i8* %416
%418 = trunc i64 %415 to i32
%419 = add i32 %285, %418
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %420
store i8 %417, i8* %421
%422 = add nuw nsw i64 %401, 3
%423 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 2, i64 %422
%424 = load i8, i8* %423
%425 = trunc i64 %422 to i32
%426 = add i32 %285, %425
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %427
store i8 %424, i8* %428
%429 = add nuw nsw i64 %401, 4
%430 = icmp eq i64 %429, %286
br i1 %430, label %431, label %400
431: ; preds = %397, %400, %357, %377, %280
%432 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 0
%433 = call i32 @strlen(i8* %432)
%434 = icmp sgt i32 %433, 0
br i1 %434, label %435, label %582
435: ; preds = %431
%436 = sub nsw i32 12, %433
%437 = zext i32 %433 to i64
%438 = icmp ult i32 %433, 8
br i1 %438, label %530, label %439
439: ; preds = %435
%440 = add nsw i64 %437, -1
%441 = sub i32 12, %433
%442 = trunc i64 %440 to i32
%443 = add i32 %441, %442
%444 = icmp slt i32 %443, %441
%445 = icmp ugt i64 %440, 4294967295
%446 = or i1 %444, %445
br i1 %446, label %530, label %447
447: ; preds = %439
%448 = icmp ult i32 %433, 32
br i1 %448, label %513, label %449
449: ; preds = %447
%450 = and i64 %437, 4294967264
%451 = add nsw i64 %450, -32
%452 = lshr exact i64 %451, 5
%453 = add nuw nsw i64 %452, 1
%454 = and i64 %453, 1
%455 = icmp eq i64 %451, 0
br i1 %455, label %491, label %456
456: ; preds = %449
%457 = and i64 %453, 1152921504606846974
br label %458
458: ; preds = %458, %456
%459 = phi i64 [ 0, %456 ], [ %488, %458 ]
%460 = phi i64 [ 0, %456 ], [ %489, %458 ]
%461 = trunc i64 %459 to i32
%462 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %459
%463 = bitcast i8* %462 to <16 x i8>*
%464 = load <16 x i8>, <16 x i8>* %463
%465 = getelementptr inbounds i8, i8* %462, i64 16
%466 = bitcast i8* %465 to <16 x i8>*
%467 = load <16 x i8>, <16 x i8>* %466
%468 = add i32 %436, %461
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %469
%471 = bitcast i8* %470 to <16 x i8>*
store <16 x i8> %464, <16 x i8>* %471
%472 = getelementptr inbounds i8, i8* %470, i64 16
%473 = bitcast i8* %472 to <16 x i8>*
store <16 x i8> %467, <16 x i8>* %473
%474 = or i64 %459, 32
%475 = trunc i64 %474 to i32
%476 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %474
%477 = bitcast i8* %476 to <16 x i8>*
%478 = load <16 x i8>, <16 x i8>* %477
%479 = getelementptr inbounds i8, i8* %476, i64 16
%480 = bitcast i8* %479 to <16 x i8>*
%481 = load <16 x i8>, <16 x i8>* %480
%482 = add i32 %436, %475
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %483
%485 = bitcast i8* %484 to <16 x i8>*
store <16 x i8> %478, <16 x i8>* %485
%486 = getelementptr inbounds i8, i8* %484, i64 16
%487 = bitcast i8* %486 to <16 x i8>*
store <16 x i8> %481, <16 x i8>* %487
%488 = add nuw i64 %459, 64
%489 = add i64 %460, 2
%490 = icmp eq i64 %489, %457
br i1 %490, label %491, label %458
491: ; preds = %458, %449
%492 = phi i64 [ 0, %449 ], [ %488, %458 ]
%493 = icmp eq i64 %454, 0
br i1 %493, label %508, label %494
494: ; preds = %491
%495 = trunc i64 %492 to i32
%496 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %492
%497 = bitcast i8* %496 to <16 x i8>*
%498 = load <16 x i8>, <16 x i8>* %497
%499 = getelementptr inbounds i8, i8* %496, i64 16
%500 = bitcast i8* %499 to <16 x i8>*
%501 = load <16 x i8>, <16 x i8>* %500
%502 = add i32 %436, %495
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %503
%505 = bitcast i8* %504 to <16 x i8>*
store <16 x i8> %498, <16 x i8>* %505
%506 = getelementptr inbounds i8, i8* %504, i64 16
%507 = bitcast i8* %506 to <16 x i8>*
store <16 x i8> %501, <16 x i8>* %507
br label %508
508: ; preds = %491, %494
%509 = icmp eq i64 %450, %437
br i1 %509, label %582, label %510
510: ; preds = %508
%511 = and i64 %437, 24
%512 = icmp eq i64 %511, 0
br i1 %512, label %530, label %513
513: ; preds = %447, %510
%514 = phi i64 [ %450, %510 ], [ 0, %447 ]
%515 = and i64 %437, 4294967288
br label %516
516: ; preds = %516, %513
%517 = phi i64 [ %514, %513 ], [ %526, %516 ]
%518 = trunc i64 %517 to i32
%519 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %517
%520 = bitcast i8* %519 to <8 x i8>*
%521 = load <8 x i8>, <8 x i8>* %520
%522 = add i32 %436, %518
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %523
%525 = bitcast i8* %524 to <8 x i8>*
store <8 x i8> %521, <8 x i8>* %525
%526 = add nuw i64 %517, 8
%527 = icmp eq i64 %526, %515
br i1 %527, label %528, label %516
528: ; preds = %516
%529 = icmp eq i64 %515, %437
br i1 %529, label %582, label %530
530: ; preds = %439, %435, %510, %528
%531 = phi i64 [ 0, %435 ], [ 0, %439 ], [ %450, %510 ], [ %515, %528 ]
%532 = xor i64 %531, -1
%533 = add nsw i64 %532, %437
%534 = and i64 %437, 3
%535 = icmp eq i64 %534, 0
br i1 %535, label %548, label %536
536: ; preds = %530, %536
%537 = phi i64 [ %545, %536 ], [ %531, %530 ]
%538 = phi i64 [ %546, %536 ], [ 0, %530 ]
%539 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %537
%540 = load i8, i8* %539
%541 = trunc i64 %537 to i32
%542 = add i32 %436, %541
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %543
store i8 %540, i8* %544
%545 = add nuw nsw i64 %537, 1
%546 = add i64 %538, 1
%547 = icmp eq i64 %546, %534
br i1 %547, label %548, label %536
548: ; preds = %536, %530
%549 = phi i64 [ %531, %530 ], [ %545, %536 ]
%550 = icmp ult i64 %533, 3
br i1 %550, label %582, label %551
551: ; preds = %548, %551
%552 = phi i64 [ %580, %551 ], [ %549, %548 ]
%553 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %552
%554 = load i8, i8* %553
%555 = trunc i64 %552 to i32
%556 = add i32 %436, %555
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %557
store i8 %554, i8* %558
%559 = add nuw nsw i64 %552, 1
%560 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %559
%561 = load i8, i8* %560
%562 = trunc i64 %559 to i32
%563 = add i32 %436, %562
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %564
store i8 %561, i8* %565
%566 = add nuw nsw i64 %552, 2
%567 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %566
%568 = load i8, i8* %567
%569 = trunc i64 %566 to i32
%570 = add i32 %436, %569
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %571
store i8 %568, i8* %572
%573 = add nuw nsw i64 %552, 3
%574 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 3, i64 %573
%575 = load i8, i8* %574
%576 = trunc i64 %573 to i32
%577 = add i32 %436, %576
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %578
store i8 %575, i8* %579
%580 = add nuw nsw i64 %552, 4
%581 = icmp eq i64 %580, %437
br i1 %581, label %582, label %551
582: ; preds = %548, %551, %508, %528, %431
%583 = getelementptr inbounds [4 x i8], [4 x i8]* %6, i64 0, i64 0
%584 = call i32 @time(i32* null)
%585 = call i32 @srand(i32 %584)
%586 = call i32 (...) @rand()
%587 = srem i32 %586, 10
%588 = trunc i32 %587 to i8
%589 = add nsw i8 %588, 48
store i8 %589, i8* %583
%590 = call i32 (...) @rand()
%591 = srem i32 %590, 10
%592 = trunc i32 %591 to i8
%593 = add nsw i8 %592, 48
%594 = getelementptr inbounds [4 x i8], [4 x i8]* %6, i64 0, i64 1
store i8 %593, i8* %594
%595 = call i32 (...) @rand()
%596 = srem i32 %595, 10
%597 = trunc i32 %596 to i8
%598 = add nsw i8 %597, 48
%599 = getelementptr inbounds [4 x i8], [4 x i8]* %6, i64 0, i64 2
store i8 %598, i8* %599
%600 = call i32 @strcpy(i8* %0, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%601 = call i32 @strcat(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%602 = call i32 @strcat(i8* %0, i8* %10)
%603 = call i32 @strcat(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%604 = call i32 @strcat(i8* %0, i8* %1)
%605 = call i32 @strcat(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%606 = call i32 @strcat(i8* %0, i8* %583)
ret void
607: ; preds = %126, %607
%608 = phi i64 [ %636, %607 ], [ %127, %126 ]
%609 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %608
%610 = load i8, i8* %609
%611 = trunc i64 %608 to i32
%612 = add i32 %14, %611
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %613
store i8 %610, i8* %614
%615 = add nuw nsw i64 %608, 1
%616 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %615
%617 = load i8, i8* %616
%618 = trunc i64 %615 to i32
%619 = add i32 %14, %618
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %620
store i8 %617, i8* %621
%622 = add nuw nsw i64 %608, 2
%623 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %622
%624 = load i8, i8* %623
%625 = trunc i64 %622 to i32
%626 = add i32 %14, %625
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %627
store i8 %624, i8* %628
%629 = add nuw nsw i64 %608, 3
%630 = getelementptr inbounds [3 x [4 x i8]], [3 x [4 x i8]]* %4, i64 0, i64 0, i64 %629
%631 = load i8, i8* %630
%632 = trunc i64 %629 to i32
%633 = add i32 %14, %632
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds [13 x i8], [13 x i8]* %5, i64 0, i64 %634
store i8 %631, i8* %635
%636 = add nuw nsw i64 %608, 4
%637 = icmp eq i64 %636, %15
br i1 %637, label %129, label %607
}