#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*/ memset(char *, char, int /*<<< orphan*/);
int /*<<< orphan*/ strlen(char *);
char *strncpy(char *strDest, const char *strSrc, size_t n) {
  char *tmpStr = strDest;
  memset(strDest, '\0', strlen(strDest));
  for (unsigned int i = 0; n != 0; n--, i++)
    *(tmpStr + i) = *(strSrc + i);
  return strDest;
}


x86 assembly (clang, -O0):
<strncpy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    -0x30(%rbp),%rdi
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x0,-0x24(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     119a <strncpy+0x7a>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1161 <strncpy+0x41>
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strncpy>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%r12
call   1030 <strlen@plt>
xor    %ebx,%ebx
mov    %r12,%rdi
xor    %esi,%esi
mov    %eax,%edx
call   1040 <memset@plt>
test   %r15,%r15
je     11f8 <strncpy+0xd8>
movabs $0xfffffffeffffffff,%rax
ff ff ff
lea    (%r15,%rax,1),%rcx
add    $0x8,%rax
cmp    %rax,%rcx
jb     117e <strncpy+0x5e>
lea    (%r14,%r15,1),%rax
cmp    %r12,%rax
jbe    1207 <strncpy+0xe7>
lea    (%r12,%r15,1),%rax
cmp    %r14,%rax
jbe    1207 <strncpy+0xe7>
mov    %r15,%rcx
lea    -0x1(%rcx),%rdi
mov    %rcx,%rdx
and    $0x3,%rdx
je     11b9 <strncpy+0x99>
mov    %ebx,%ebx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r14,%rbx,1),%eax
mov    %al,(%r12,%rbx,1)
add    $0x1,%rsi
add    $0x1,%rbx
cmp    %rsi,%rdx
jne    11a0 <strncpy+0x80>
sub    %rsi,%rcx
cmp    $0x3,%rdi
jb     11f8 <strncpy+0xd8>
nop
mov    %ebx,%eax
movzbl (%r14,%rax,1),%edx
mov    %dl,(%r12,%rax,1)
lea    0x1(%rbx),%eax
movzbl (%r14,%rax,1),%edx
mov    %dl,(%r12,%rax,1)
lea    0x2(%rbx),%eax
movzbl (%r14,%rax,1),%edx
mov    %dl,(%r12,%rax,1)
lea    0x3(%rbx),%eax
movzbl (%r14,%rax,1),%edx
mov    %dl,(%r12,%rax,1)
add    $0x4,%ebx
add    $0xfffffffffffffffc,%rcx
jne    11c0 <strncpy+0xa0>
mov    %r12,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
cmp    $0x20,%r15
jae    1214 <strncpy+0xf4>
xor    %eax,%eax
jmp    12f4 <strncpy+0x1d4>
mov    %r15,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x60,%rdx
jae    1239 <strncpy+0x119>
xor    %edx,%edx
jmp    12ad <strncpy+0x18d>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nop
mov    %edx,%edi
and    $0xffffff80,%edi
movups (%r14,%rdi,1),%xmm0
movups 0x10(%r14,%rdi,1),%xmm1
movups %xmm0,(%r12,%rdi,1)
movups %xmm1,0x10(%r12,%rdi,1)
movups 0x20(%r14,%rdi,1),%xmm0
movups 0x30(%r14,%rdi,1),%xmm1
movups %xmm0,0x20(%r12,%rdi,1)
movups %xmm1,0x30(%r12,%rdi,1)
movups 0x40(%r14,%rdi,1),%xmm0
movups 0x50(%r14,%rdi,1),%xmm1
movups %xmm0,0x40(%r12,%rdi,1)
movups %xmm1,0x50(%r12,%rdi,1)
movups 0x60(%r14,%rdi,1),%xmm0
movups 0x70(%r14,%rdi,1),%xmm1
movups %xmm0,0x60(%r12,%rdi,1)
movups %xmm1,0x70(%r12,%rdi,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1240 <strncpy+0x120>
test   %rcx,%rcx
je     12e5 <strncpy+0x1c5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edx,%esi
and    $0xffffffe0,%esi
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%r12,%rsi,1)
movups %xmm1,0x10(%r12,%rsi,1)
add    $0x20,%rdx
add    $0xffffffffffffffff,%rcx
jne    12c0 <strncpy+0x1a0>
cmp    %r15,%rax
je     11f8 <strncpy+0xd8>
test   $0x18,%r15b
je     1334 <strncpy+0x214>
mov    %r15,%rbx
and    $0xfffffffffffffff8,%rbx
mov    %r15d,%ecx
and    $0x7,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,%edx
and    $0xfffffff8,%edx
mov    (%r14,%rdx,1),%rsi
mov    %rsi,(%r12,%rdx,1)
add    $0x8,%rax
cmp    %rax,%rbx
jne    1310 <strncpy+0x1f0>
cmp    %r15,%rbx
jne    1181 <strncpy+0x61>
jmp    11f8 <strncpy+0xd8>
and    $0x1f,%r15d
mov    %eax,%ebx
jmp    117e <strncpy+0x5e>

LLVM IR (-O0):
define i8* @strncpy(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%9 = load i8*, i8** %4
store i8* %9, i8** %7
%10 = load i8*, i8** %4
%11 = load i8*, i8** %4
%12 = call i32 @strlen(i8* %11)
%13 = call i32 @memset(i8* %10, i8 signext 0, i32 %12)
store i32 0, i32* %8
br label %14
14: ; preds = %27, %3
%15 = load i64, i64* %6
%16 = icmp ne i64 %15, 0
br i1 %16, label %17, label %32
17: ; preds = %14
%18 = load i8*, i8** %5
%19 = load i32, i32* %8
%20 = zext i32 %19 to i64
%21 = getelementptr inbounds i8, i8* %18, i64 %20
%22 = load i8, i8* %21
%23 = load i8*, i8** %7
%24 = load i32, i32* %8
%25 = zext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
store i8 %22, i8* %26
br label %27
27: ; preds = %17
%28 = load i64, i64* %6
%29 = add i64 %28, -1
store i64 %29, i64* %6
%30 = load i32, i32* %8
%31 = add i32 %30, 1
store i32 %31, i32* %8
br label %14
32: ; preds = %14
%33 = load i8*, i8** %4
ret i8* %33
}

LLVM IR (-O2):
define i8* @strncpy(i8* returned %0, i8* nocapture %1, i64 %2) {
%4 = tail call i32 @strlen(i8* %0)
%5 = tail call i32 @memset(i8* %0, i8 signext 0, i32 %4)
%6 = icmp eq i64 %2, 0
br i1 %6, label %146, label %7
7: ; preds = %3
%8 = add i64 %2, -4294967297
%9 = icmp ult i64 %8, -4294967289
br i1 %9, label %124, label %10
10: ; preds = %7
%11 = getelementptr i8, i8* %0, i64 %2
%12 = getelementptr i8, i8* %1, i64 %2
%13 = icmp ugt i8* %12, %0
%14 = icmp ugt i8* %11, %1
%15 = and i1 %13, %14
br i1 %15, label %124, label %16
16: ; preds = %10
%17 = icmp ult i64 %2, 32
br i1 %17, label %107, label %18
18: ; preds = %16
%19 = and i64 %2, -32
%20 = add i64 %19, -32
%21 = lshr exact i64 %20, 5
%22 = add nuw nsw i64 %21, 1
%23 = and i64 %22, 3
%24 = icmp ult i64 %20, 96
br i1 %24, label %80, label %25
25: ; preds = %18
%26 = and i64 %22, 1152921504606846972
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %77, %27 ]
%29 = phi i64 [ 0, %25 ], [ %78, %27 ]
%30 = and i64 %28, 4294967168
%31 = getelementptr inbounds i8, i8* %1, i64 %30
%32 = bitcast i8* %31 to <16 x i8>*
%33 = load <16 x i8>, <16 x i8>* %32
%34 = getelementptr inbounds i8, i8* %31, i64 16
%35 = bitcast i8* %34 to <16 x i8>*
%36 = load <16 x i8>, <16 x i8>* %35
%37 = getelementptr inbounds i8, i8* %0, i64 %30
%38 = bitcast i8* %37 to <16 x i8>*
store <16 x i8> %33, <16 x i8>* %38
%39 = getelementptr inbounds i8, i8* %37, i64 16
%40 = bitcast i8* %39 to <16 x i8>*
store <16 x i8> %36, <16 x i8>* %40
%41 = and i64 %28, 4294967168
%42 = or i64 %41, 32
%43 = getelementptr inbounds i8, i8* %1, i64 %42
%44 = bitcast i8* %43 to <16 x i8>*
%45 = load <16 x i8>, <16 x i8>* %44
%46 = getelementptr inbounds i8, i8* %43, i64 16
%47 = bitcast i8* %46 to <16 x i8>*
%48 = load <16 x i8>, <16 x i8>* %47
%49 = getelementptr inbounds i8, i8* %0, i64 %42
%50 = bitcast i8* %49 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %50
%51 = getelementptr inbounds i8, i8* %49, i64 16
%52 = bitcast i8* %51 to <16 x i8>*
store <16 x i8> %48, <16 x i8>* %52
%53 = and i64 %28, 4294967168
%54 = or i64 %53, 64
%55 = getelementptr inbounds i8, i8* %1, i64 %54
%56 = bitcast i8* %55 to <16 x i8>*
%57 = load <16 x i8>, <16 x i8>* %56
%58 = getelementptr inbounds i8, i8* %55, i64 16
%59 = bitcast i8* %58 to <16 x i8>*
%60 = load <16 x i8>, <16 x i8>* %59
%61 = getelementptr inbounds i8, i8* %0, i64 %54
%62 = bitcast i8* %61 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %62
%63 = getelementptr inbounds i8, i8* %61, i64 16
%64 = bitcast i8* %63 to <16 x i8>*
store <16 x i8> %60, <16 x i8>* %64
%65 = and i64 %28, 4294967168
%66 = or i64 %65, 96
%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* %0, 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 i64 %28, 128
%78 = add i64 %29, 4
%79 = icmp eq i64 %78, %26
br i1 %79, label %80, label %27
80: ; preds = %27, %18
%81 = phi i64 [ 0, %18 ], [ %77, %27 ]
%82 = icmp eq i64 %23, 0
br i1 %82, label %100, label %83
83: ; preds = %80, %83
%84 = phi i64 [ %97, %83 ], [ %81, %80 ]
%85 = phi i64 [ %98, %83 ], [ 0, %80 ]
%86 = and i64 %84, 4294967264
%87 = getelementptr inbounds i8, i8* %1, i64 %86
%88 = bitcast i8* %87 to <16 x i8>*
%89 = load <16 x i8>, <16 x i8>* %88
%90 = getelementptr inbounds i8, i8* %87, i64 16
%91 = bitcast i8* %90 to <16 x i8>*
%92 = load <16 x i8>, <16 x i8>* %91
%93 = getelementptr inbounds i8, i8* %0, i64 %86
%94 = bitcast i8* %93 to <16 x i8>*
store <16 x i8> %89, <16 x i8>* %94
%95 = getelementptr inbounds i8, i8* %93, i64 16
%96 = bitcast i8* %95 to <16 x i8>*
store <16 x i8> %92, <16 x i8>* %96
%97 = add nuw i64 %84, 32
%98 = add i64 %85, 1
%99 = icmp eq i64 %98, %23
br i1 %99, label %100, label %83
100: ; preds = %83, %80
%101 = icmp eq i64 %19, %2
br i1 %101, label %146, label %102
102: ; preds = %100
%103 = and i64 %2, 31
%104 = trunc i64 %19 to i32
%105 = and i64 %2, 24
%106 = icmp eq i64 %105, 0
br i1 %106, label %124, label %107
107: ; preds = %16, %102
%108 = phi i64 [ %19, %102 ], [ 0, %16 ]
%109 = and i64 %2, -8
%110 = trunc i64 %109 to i32
%111 = and i64 %2, 7
br label %112
112: ; preds = %112, %107
%113 = phi i64 [ %108, %107 ], [ %120, %112 ]
%114 = and i64 %113, 4294967288
%115 = getelementptr inbounds i8, i8* %1, i64 %114
%116 = bitcast i8* %115 to <8 x i8>*
%117 = load <8 x i8>, <8 x i8>* %116
%118 = getelementptr inbounds i8, i8* %0, i64 %114
%119 = bitcast i8* %118 to <8 x i8>*
store <8 x i8> %117, <8 x i8>* %119
%120 = add nuw i64 %113, 8
%121 = icmp eq i64 %120, %109
br i1 %121, label %122, label %112
122: ; preds = %112
%123 = icmp eq i64 %109, %2
br i1 %123, label %146, label %124
124: ; preds = %10, %7, %102, %122
%125 = phi i32 [ 0, %7 ], [ 0, %10 ], [ %104, %102 ], [ %110, %122 ]
%126 = phi i64 [ %2, %7 ], [ %2, %10 ], [ %103, %102 ], [ %111, %122 ]
%127 = add i64 %126, -1
%128 = and i64 %126, 3
%129 = icmp eq i64 %128, 0
br i1 %129, label %142, label %130
130: ; preds = %124, %130
%131 = phi i32 [ %139, %130 ], [ %125, %124 ]
%132 = phi i64 [ %138, %130 ], [ %126, %124 ]
%133 = phi i64 [ %140, %130 ], [ 0, %124 ]
%134 = zext i32 %131 to i64
%135 = getelementptr inbounds i8, i8* %1, i64 %134
%136 = load i8, i8* %135
%137 = getelementptr inbounds i8, i8* %0, i64 %134
store i8 %136, i8* %137
%138 = add i64 %132, -1
%139 = add i32 %131, 1
%140 = add i64 %133, 1
%141 = icmp eq i64 %140, %128
br i1 %141, label %142, label %130
142: ; preds = %130, %124
%143 = phi i32 [ %125, %124 ], [ %139, %130 ]
%144 = phi i64 [ %126, %124 ], [ %138, %130 ]
%145 = icmp ult i64 %127, 3
br i1 %145, label %146, label %147
146: ; preds = %142, %147, %100, %122, %3
ret i8* %0
147: ; preds = %142, %147
%148 = phi i32 [ %170, %147 ], [ %143, %142 ]
%149 = phi i64 [ %169, %147 ], [ %144, %142 ]
%150 = zext i32 %148 to i64
%151 = getelementptr inbounds i8, i8* %1, i64 %150
%152 = load i8, i8* %151
%153 = getelementptr inbounds i8, i8* %0, i64 %150
store i8 %152, i8* %153
%154 = add i32 %148, 1
%155 = zext i32 %154 to i64
%156 = getelementptr inbounds i8, i8* %1, i64 %155
%157 = load i8, i8* %156
%158 = getelementptr inbounds i8, i8* %0, i64 %155
store i8 %157, i8* %158
%159 = add i32 %148, 2
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds i8, i8* %1, i64 %160
%162 = load i8, i8* %161
%163 = getelementptr inbounds i8, i8* %0, i64 %160
store i8 %162, i8* %163
%164 = add i32 %148, 3
%165 = zext i32 %164 to i64
%166 = getelementptr inbounds i8, i8* %1, i64 %165
%167 = load i8, i8* %166
%168 = getelementptr inbounds i8, i8* %0, i64 %165
store i8 %167, i8* %168
%169 = add i64 %149, -4
%170 = add i32 %148, 4
%171 = icmp eq i64 %169, 0
br i1 %171, label %146, label %147
}