#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 ft_strlenz(char const *);
scalar_t__ malloc(int);
char *ft_strdupz(const char *s1) {
  char *s2;
  int n;
  n = ft_strlenz(s1) + 1;
  s2 = (char *)malloc(n);
  while (n >= 0) {
    s2[n] = s1[n];
    n--;
  }
  return (s2);
}


x86 assembly (clang, -O0):
<ft_strdupz>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <ft_strlenz@plt>
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%edi
call   1040 <malloc@plt>
mov    %rax,-0x10(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     1175 <ft_strdupz+0x55>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1147 <ft_strdupz+0x27>
mov    -0x10(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ft_strdupz>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r13
call   1030 <ft_strlenz@plt>
mov    %eax,%r14d
lea    0x1(%r14),%r12d
mov    %r12d,%edi
call   1040 <malloc@plt>
cmp    $0xffffffff,%r14d
jl     11c4 <ft_strdupz+0xa4>
mov    %rax,%rcx
xor    %esi,%esi
test   %r12d,%r12d
mov    $0x0,%edi
cmovs  %r12d,%edi
mov    %r12d,%r10d
mov    %r14d,%edx
sub    %edi,%edx
add    $0x1,%edx
cmp    $0x3,%edx
jb     119f <ft_strdupz+0x7f>
test   %r12d,%r12d
cmovs  %r12d,%esi
mov    %r14d,%edi
sub    %esi,%edi
add    $0x1,%edi
mov    %r10,%rsi
sub    %rdi,%rsi
lea    (%rcx,%rsi,1),%rdi
lea    (%r10,%r13,1),%rbp
add    $0x1,%rbp
cmp    %rbp,%rdi
jae    11d3 <ft_strdupz+0xb3>
lea    (%rcx,%r10,1),%rdi
add    $0x1,%rdi
add    %r13,%rsi
cmp    %rdi,%rsi
jae    11d3 <ft_strdupz+0xb3>
mov    %r10,%rdx
lea    0x1(%rdx),%esi
add    %rdx,%rcx
add    %rdx,%r13
xor    %edx,%edx
nopl   (%rax)
movzbl 0x0(%r13,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,1)
add    $0xffffffffffffffff,%rdx
lea    (%rsi,%rdx,1),%edi
test   %edi,%edi
jg     11b0 <ft_strdupz+0x90>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1(%rdx),%r15
movabs $0x1fffffff0,%r8
xor    %r9d,%r9d
cmp    $0xf,%edx
jae    11f0 <ft_strdupz+0xd0>
xor    %edi,%edi
jmp    12b3 <ft_strdupz+0x193>
mov    %r15,%rdi
and    %r8,%rdi
lea    -0x10(%rdi),%rsi
mov    %rsi,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %edx,%r11d
and    $0x3,%r11d
cmp    $0x30,%rsi
jae    1216 <ft_strdupz+0xf6>
xor    %esi,%esi
jmp    1264 <ft_strdupz+0x144>
and    $0xfffffffffffffffc,%rdx
lea    (%rcx,%r10,1),%rbp
add    $0xfffffffffffffff1,%rbp
lea    (%r10,%r13,1),%rbx
add    $0xfffffffffffffff1,%rbx
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rbx,%rsi,1),%xmm0
movups %xmm0,0x0(%rbp,%rsi,1)
movups -0x10(%rbx,%rsi,1),%xmm0
movups %xmm0,-0x10(%rbp,%rsi,1)
movups -0x20(%rbx,%rsi,1),%xmm0
movups %xmm0,-0x20(%rbp,%rsi,1)
movups -0x30(%rbx,%rsi,1),%xmm0
movups %xmm0,-0x30(%rbp,%rsi,1)
add    $0xffffffffffffffc0,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1230 <ft_strdupz+0x110>
neg    %rsi
test   %r11,%r11
je     12a4 <ft_strdupz+0x184>
mov    %r10,%rbx
sub    %rsi,%rbx
lea    (%rcx,%rbx,1),%rdx
add    $0xfffffffffffffff1,%rdx
lea    (%rbx,%r13,1),%rsi
add    $0xfffffffffffffff1,%rsi
shl    $0x4,%r11
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rsi,%rbx,1),%xmm0
movups %xmm0,(%rdx,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r11,%rbp
add    %rbx,%rbp
jne    1290 <ft_strdupz+0x170>
cmp    %rdi,%r15
je     11c4 <ft_strdupz+0xa4>
test   $0xc,%r15b
je     130e <ft_strdupz+0x1ee>
test   %r12d,%r12d
cmovs  %r12d,%r9d
sub    %r9d,%r14d
add    $0x1,%r14d
add    $0x1,%r14
add    $0xc,%r8
and    %r14,%r8
mov    %r10,%rdx
sub    %r8,%rdx
and    $0xfffffffffffffffc,%r15
neg    %r15
neg    %rdi
lea    (%rcx,%r10,1),%rsi
add    $0xfffffffffffffffd,%rsi
lea    (%r10,%r13,1),%rbp
add    $0xfffffffffffffffd,%rbp
nopl   0x0(%rax)
mov    0x0(%rbp,%rdi,1),%ebx
mov    %ebx,(%rsi,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%r15
jne    12f0 <ft_strdupz+0x1d0>
cmp    %r8,%r14
jne    11a2 <ft_strdupz+0x82>
jmp    11c4 <ft_strdupz+0xa4>
sub    %rdi,%r10
jmp    119f <ft_strdupz+0x7f>

LLVM IR (-O0):
define i8* @ft_strdupz(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i32
store i8* %0, i8** %2
%5 = load i8*, i8** %2
%6 = call i32 @ft_strlenz(i8* %5)
%7 = add nsw i32 %6, 1
store i32 %7, i32* %4
%8 = load i32, i32* %4
%9 = call i64 @malloc(i32 %8)
%10 = inttoptr i64 %9 to i8*
store i8* %10, i8** %3
br label %11
11: ; preds = %14, %1
%12 = load i32, i32* %4
%13 = icmp sge i32 %12, 0
br i1 %13, label %14, label %26
14: ; preds = %11
%15 = load i8*, i8** %2
%16 = load i32, i32* %4
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %15, i64 %17
%19 = load i8, i8* %18
%20 = load i8*, i8** %3
%21 = load i32, i32* %4
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %20, i64 %22
store i8 %19, i8* %23
%24 = load i32, i32* %4
%25 = add nsw i32 %24, -1
store i32 %25, i32* %4
br label %11
26: ; preds = %11
%27 = load i8*, i8** %3
ret i8* %27
}

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