#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 */
char *ft_strjoinnchar2(char *, int, char);
int ft_strlen(char *);
scalar_t__ malloc(int);
char *ft_strjoinnchar(char *s, int n, char c) {
  char *new;
  int len;
  if (n < 0)
    return (ft_strjoinnchar2(s, -n, c));
  len = ft_strlen(s);
  if (!(new = (char *)malloc(len + n + 1)))
    return (NULL);
  new[len + n] = '\0';
  while (s && len--)
    new[len + n] = s[len];
  while (n--)
    new[n] = c;
  return (new);
}


x86 assembly (clang, -O0):
<ft_strjoinnchar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %dl,%al
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %al,-0x15(%rbp)
cmpl   $0x0,-0x14(%rbp)
jge    1169 <ft_strjoinnchar+0x39>
mov    -0x10(%rbp),%rdi
xor    %esi,%esi
sub    -0x14(%rbp),%esi
movsbl -0x15(%rbp),%edx
call   1040 <ft_strjoinnchar2@plt>
mov    %rax,-0x8(%rbp)
jmp    1237 <ft_strjoinnchar+0x107>
mov    -0x10(%rbp),%rdi
call   1030 <ft_strlen@plt>
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%edi
add    -0x14(%rbp),%edi
add    $0x1,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    119e <ft_strjoinnchar+0x6e>
movq   $0x0,-0x8(%rbp)
jmp    1237 <ft_strjoinnchar+0x107>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x25(%rbp)
je     11d3 <ft_strjoinnchar+0xa3>
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x0,%eax
setne  %al
mov    %al,-0x25(%rbp)
mov    -0x25(%rbp),%al
test   $0x1,%al
jne    11e3 <ft_strjoinnchar+0xb3>
jmp    1203 <ft_strjoinnchar+0xd3>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11af <ft_strjoinnchar+0x7f>
jmp    1208 <ft_strjoinnchar+0xd8>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     122f <ft_strjoinnchar+0xff>
mov    -0x15(%rbp),%dl
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1208 <ft_strjoinnchar+0xd8>
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ft_strjoinnchar>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edx,%r14d
mov    %esi,%r12d
mov    %rdi,%rbp
test   %esi,%esi
js     11cc <ft_strjoinnchar+0x8c>
mov    %rbp,%rdi
call   1030 <ft_strlen@plt>
mov    %eax,%ebx
lea    (%rbx,%r12,1),%edi
add    $0x1,%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     11e6 <ft_strjoinnchar+0xa6>
mov    %rax,%r15
lea    (%rbx,%r12,1),%eax
cltq
movb   $0x0,(%r15,%rax,1)
mov    %r12d,%edx
test   %rbp,%rbp
je     135d <ft_strjoinnchar+0x21d>
test   %ebx,%ebx
je     135d <ft_strjoinnchar+0x21d>
movslq %ebx,%r10
lea    -0x1(%r10),%r9
cmp    $0x4,%ebx
jb     12f9 <ft_strjoinnchar+0x1b9>
lea    (%r15,%rdx,1),%rax
lea    (%r10,%rdx,1),%r8
lea    (%r10,%rbp,1),%rcx
cmp    %rcx,%rax
jae    11c0 <ft_strjoinnchar+0x80>
lea    (%r15,%r8,1),%rax
cmp    %rbp,%rax
ja     12f9 <ft_strjoinnchar+0x1b9>
cmp    $0x10,%ebx
jae    11ee <ft_strjoinnchar+0xae>
xor    %edi,%edi
jmp    12b3 <ft_strjoinnchar+0x173>
neg    %r12d
movsbl %r14b,%edx
mov    %rbp,%rdi
mov    %r12d,%esi
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <ft_strjoinnchar2@plt>
xor    %r15d,%r15d
jmp    137b <ft_strjoinnchar+0x23b>
mov    %r10,%rdi
and    $0xfffffffffffffff0,%rdi
lea    -0x10(%rdi),%rax
mov    %rax,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
mov    %ebx,%r11d
and    $0x3,%r11d
cmp    $0x30,%rax
jae    1215 <ft_strjoinnchar+0xd5>
xor    %esi,%esi
jmp    1263 <ft_strjoinnchar+0x123>
and    $0xfffffffffffffffc,%rbx
lea    (%r15,%r8,1),%rcx
add    $0xfffffffffffffff0,%rcx
lea    (%r10,%rbp,1),%rax
add    $0xfffffffffffffff0,%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%rax,%rsi,1),%xmm0
movups %xmm0,(%rcx,%rsi,1)
movups -0x10(%rax,%rsi,1),%xmm0
movups %xmm0,-0x10(%rcx,%rsi,1)
movups -0x20(%rax,%rsi,1),%xmm0
movups %xmm0,-0x20(%rcx,%rsi,1)
movups -0x30(%rax,%rsi,1),%xmm0
movups %xmm0,-0x30(%rcx,%rsi,1)
add    $0xffffffffffffffc0,%rsi
add    $0xfffffffffffffffc,%rbx
jne    1230 <ft_strjoinnchar+0xf0>
neg    %rsi
test   %r11,%r11
je     12a4 <ft_strjoinnchar+0x164>
mov    %r8,%rax
sub    %rsi,%rax
add    %r15,%rax
add    $0xfffffffffffffff0,%rax
mov    %r10,%rcx
sub    %rsi,%rcx
add    %rbp,%rcx
add    $0xfffffffffffffff0,%rcx
shl    $0x4,%r11
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%rcx,%rsi,1),%xmm0
movups %xmm0,(%rax,%rsi,1)
add    $0xfffffffffffffff0,%rsi
mov    %r11,%rbx
add    %rsi,%rbx
jne    1290 <ft_strjoinnchar+0x150>
cmp    %r10,%rdi
je     135d <ft_strjoinnchar+0x21d>
test   $0xc,%r10b
je     12f6 <ft_strjoinnchar+0x1b6>
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
sub    %r11,%r9
mov    %r11,%rcx
neg    %rcx
neg    %rdi
lea    (%r10,%rbp,1),%rsi
add    $0xfffffffffffffffc,%rsi
lea    (%r15,%r8,1),%rbx
add    $0xfffffffffffffffc,%rbx
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rdi,1),%eax
mov    %eax,(%rbx,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rcx
jne    12e0 <ft_strjoinnchar+0x1a0>
cmp    %r10,%r11
jne    12f9 <ft_strjoinnchar+0x1b9>
jmp    135d <ft_strjoinnchar+0x21d>
sub    %rdi,%r9
lea    0x1(%r9),%eax
mov    %r9,%rcx
and    $0x3,%rax
je     1322 <ft_strjoinnchar+0x1e2>
lea    (%r15,%rdx,1),%rsi
mov    %r9,%rcx
nopl   (%rax)
movzbl 0x0(%rbp,%rcx,1),%ebx
mov    %bl,(%rsi,%rcx,1)
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%rax
jne    1310 <ft_strjoinnchar+0x1d0>
cmp    $0x3,%r9
jb     135d <ft_strjoinnchar+0x21d>
lea    (%r15,%rdx,1),%rax
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rcx,1),%ebx
mov    %bl,(%rax,%rcx,1)
movzbl -0x1(%rbp,%rcx,1),%ebx
mov    %bl,-0x1(%rax,%rcx,1)
movzbl -0x2(%rbp,%rcx,1),%ebx
mov    %bl,-0x2(%rax,%rcx,1)
movzbl -0x3(%rbp,%rcx,1),%ebx
mov    %bl,-0x3(%rax,%rcx,1)
add    $0xfffffffffffffffc,%rcx
cmp    $0xffffffffffffffff,%rcx
jne    1330 <ft_strjoinnchar+0x1f0>
test   %r12d,%r12d
je     137b <ft_strjoinnchar+0x23b>
add    $0xffffffff,%r12d
movslq %r12d,%rax
sub    %r12,%rax
mov    %r15,%rdi
add    %rax,%rdi
movzbl %r14b,%esi
call   1050 <memset@plt>
mov    %r15,%rax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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