#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 countWordInBuff(char const *, char const *);
scalar_t__ malloc(int);
int strlen(char const *);
char *replaceNWord(const char *buffer, const char *old, const char *nw,
                   int count) {
  int numOldWord = 0;
  int firstPos = 0;
  int index = 0, index2 = 0, index3 = 0;
  int numRep = 0;
  char *newBuff = NULL;
  int sizeOldBuff = 0;
  int sizeOldWord = 0;
  int sizeNewBuff = 0;
  int sizeNewWord = 0;
  char fact1 = 0;
  if (buffer == NULL || old == NULL || nw == NULL || count == 0) {
    return NULL;
  } else {
  }
  sizeOldWord = strlen(old);
  sizeNewWord = strlen(nw);
  sizeOldBuff = strlen(buffer);
  numOldWord = countWordInBuff(buffer, old);
  if (count > 0 && count <= numOldWord) {
    numOldWord = count;
  } else {
  }
  if (numOldWord == 0) {
    return 0;
  } else {
  }
  sizeNewBuff = 1 + sizeOldBuff + (sizeNewWord - sizeOldWord) * numOldWord;
  newBuff = (char *)malloc(sizeof(char) * sizeNewBuff);
  if (newBuff == NULL) {
    return NULL;
  } else {
  }
  for (index = 0; index < sizeOldBuff; index++) {
    fact1 = (numRep < count) || count < 0;
    if (buffer[index] == old[index2] && index2 < sizeOldWord && fact1) {
      if (index2 == 0 && sizeOldWord > 1) {
        firstPos = index;
      } else if (index2 + 1 == sizeOldWord) {
        for (index2 = 0; index2 < sizeNewWord; index2++) {
          newBuff[index3++] = nw[index2];
        }
        numRep++;
      } else {
      }
      index2++;
    } else if (index2 < sizeOldWord && index2 > 0) {
      index = firstPos;
      index2 = 0;
      newBuff[index3++] = buffer[index];
    } else {
      newBuff[index3++] = buffer[index];
      index2 = 0;
    }
  }
  newBuff[index3] = '\0';
  return newBuff;
}


x86 assembly (clang, -O0):
<replaceNWord>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movq   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movb   $0x0,-0x59(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     11c4 <replaceNWord+0x94>
cmpq   $0x0,-0x18(%rbp)
je     11c4 <replaceNWord+0x94>
cmpq   $0x0,-0x20(%rbp)
je     11c4 <replaceNWord+0x94>
cmpl   $0x0,-0x24(%rbp)
jne    11d1 <replaceNWord+0xa1>
movq   $0x0,-0x8(%rbp)
jmp    1433 <replaceNWord+0x303>
jmp    11d6 <replaceNWord+0xa6>
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x50(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1050 <countWordInBuff@plt>
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    122b <replaceNWord+0xfb>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     122b <replaceNWord+0xfb>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    1230 <replaceNWord+0x100>
jmp    1230 <replaceNWord+0x100>
cmpl   $0x0,-0x28(%rbp)
jne    1247 <replaceNWord+0x117>
movq   $0x0,-0x8(%rbp)
jmp    1433 <replaceNWord+0x303>
jmp    124c <replaceNWord+0x11c>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
movslq -0x54(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    128c <replaceNWord+0x15c>
movq   $0x0,-0x8(%rbp)
jmp    1433 <replaceNWord+0x303>
jmp    1291 <replaceNWord+0x161>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    141f <replaceNWord+0x2ef>
mov    -0x3c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x24(%rbp),%ecx
mov    %al,-0x5a(%rbp)
jl     12bf <replaceNWord+0x18f>
cmpl   $0x0,-0x24(%rbp)
setl   %al
mov    %al,-0x5a(%rbp)
mov    -0x5a(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x59(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1398 <replaceNWord+0x268>
mov    -0x34(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1398 <replaceNWord+0x268>
movsbl -0x59(%rbp),%eax
cmp    $0x0,%eax
je     1398 <replaceNWord+0x268>
cmpl   $0x0,-0x34(%rbp)
jne    1322 <replaceNWord+0x1f2>
cmpl   $0x1,-0x50(%rbp)
jle    1322 <replaceNWord+0x1f2>
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    138a <replaceNWord+0x25a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cmp    -0x50(%rbp),%eax
jne    1380 <replaceNWord+0x250>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1372 <replaceNWord+0x242>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1338 <replaceNWord+0x208>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1385 <replaceNWord+0x255>
jmp    1385 <replaceNWord+0x255>
jmp    138a <replaceNWord+0x25a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    140c <replaceNWord+0x2dc>
mov    -0x34(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    13e0 <replaceNWord+0x2b0>
cmpl   $0x0,-0x34(%rbp)
jle    13e0 <replaceNWord+0x2b0>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1407 <replaceNWord+0x2d7>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x34(%rbp)
jmp    140c <replaceNWord+0x2dc>
jmp    1411 <replaceNWord+0x2e1>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1298 <replaceNWord+0x168>
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x48(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<replaceNWord>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
xor    %eax,%eax
test   %rdi,%rdi
je     14d7 <replaceNWord+0x3a7>
test   %rsi,%rsi
je     14d7 <replaceNWord+0x3a7>
mov    %rdx,%r13
test   %rdx,%rdx
je     14d7 <replaceNWord+0x3a7>
test   %ecx,%ecx
je     14d7 <replaceNWord+0x3a7>
mov    %rdi,%rbp
mov    %rsi,%rdi
mov    %ecx,%r12d
mov    %rsi,%r15
call   1030 <strlen@plt>
mov    %eax,0x14(%rsp)
mov    %r13,%rdi
call   1030 <strlen@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1030 <strlen@plt>
mov    %eax,%r14d
mov    %rbp,%rdi
mov    %r15,0x70(%rsp)
mov    %r15,%rsi
mov    %r12d,%r15d
call   1050 <countWordInBuff@plt>
cmp    %r12d,%eax
mov    %r12d,%ecx
cmovl  %eax,%ecx
test   %r12d,%r12d
cmovle %eax,%ecx
test   %ecx,%ecx
je     14cc <replaceNWord+0x39c>
mov    %ebx,0x4(%rsp)
mov    0x14(%rsp),%r12d
sub    %r12d,%ebx
imul   %ebx,%ecx
lea    (%r14,%rcx,1),%edi
add    $0x1,%edi
call   1040 <malloc@plt>
xor    %r10d,%r10d
test   %rax,%rax
je     14cc <replaceNWord+0x39c>
mov    %r14,%rbx
test   %ebx,%ebx
mov    0x4(%rsp),%r11d
jle    14d0 <replaceNWord+0x3a0>
mov    %r11d,%r9d
lea    (%rax,%r9,1),%rcx
mov    %rcx,0x58(%rsp)
lea    (%r9,%r13,1),%rcx
mov    %rcx,0x60(%rsp)
mov    %r9d,%ecx
and    $0xffffffe0,%ecx
mov    %rcx,0x50(%rsp)
add    $0xffffffffffffffe0,%rcx
mov    %rcx,0x48(%rsp)
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%edx
and    $0x3,%edx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x20(%rsp)
mov    %r9d,%ecx
and    $0x3,%ecx
mov    %rcx,0x68(%rsp)
lea    0x70(%rax),%rcx
mov    %rcx,0x18(%rsp)
lea    0x10(%r13),%rcx
mov    %rcx,0x30(%rsp)
lea    0x10(%rax),%rcx
mov    %rcx,0x28(%rsp)
mov    %rdx,0x40(%rsp)
shl    $0x5,%rdx
mov    %rdx,0x38(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x8(%rsp)
xor    %r10d,%r10d
xor    %esi,%esi
xor    %r8d,%r8d
xor    %r14d,%r14d
jmp    1299 <replaceNWord+0x169>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rcx),%r10d
mov    %dl,(%rax,%rcx,1)
xor    %esi,%esi
mov    %rdi,%rbx
add    $0x1,%r8d
cmp    %ebx,%r8d
jge    14d0 <replaceNWord+0x3a0>
mov    %rbx,%rdi
movslq %r8d,%rcx
mov    0x0(%rbp,%rcx,1),%dl
movslq %esi,%rcx
mov    0x70(%rsp),%rbx
cmp    (%rbx,%rcx,1),%dl
jne    12e0 <replaceNWord+0x1b0>
test   %r15d,%r15d
sets   %cl
cmp    %r15d,0x8(%rsp)
setl   %bl
cmp    %r12d,%esi
jge    12e0 <replaceNWord+0x1b0>
or     %bl,%cl
je     12e0 <replaceNWord+0x1b0>
test   %esi,%esi
jne    1301 <replaceNWord+0x1d1>
cmp    $0x1,%r12d
jle    1301 <replaceNWord+0x1d1>
mov    %r8d,%r14d
xor    %esi,%esi
jmp    13cd <replaceNWord+0x29d>
nopl   0x0(%rax,%rax,1)
movslq %r10d,%rcx
cmp    %r12d,%esi
jge    1280 <replaceNWord+0x150>
test   %esi,%esi
jle    1280 <replaceNWord+0x150>
movslq %r14d,%rdx
mov    0x0(%rbp,%rdx,1),%dl
lea    0x1(%rcx),%r10d
mov    %dl,(%rax,%rcx,1)
xor    %esi,%esi
mov    %r14d,%r8d
jmp    1289 <replaceNWord+0x159>
lea    0x1(%rsi),%ecx
cmp    %r12d,%ecx
jne    13cd <replaceNWord+0x29d>
test   %r11d,%r11d
mov    %rdi,%rbx
jle    13d8 <replaceNWord+0x2a8>
movslq %r10d,%r10
cmp    $0x20,%r11d
jb     1342 <replaceNWord+0x212>
lea    (%rax,%r10,1),%rcx
cmp    0x60(%rsp),%rcx
jae    13df <replaceNWord+0x2af>
mov    0x58(%rsp),%rcx
add    %r10,%rcx
cmp    %r13,%rcx
jbe    13df <replaceNWord+0x2af>
xor    %esi,%esi
mov    %rsi,%rdx
not    %rdx
add    %r9,%rdx
mov    0x68(%rsp),%rcx
test   %rcx,%rcx
je     1378 <replaceNWord+0x248>
nopw   0x0(%rax,%rax,1)
movzbl 0x0(%r13,%rsi,1),%ebx
mov    %bl,(%rax,%r10,1)
add    $0x1,%r10
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1360 <replaceNWord+0x230>
cmp    $0x3,%rdx
mov    %rdi,%rbx
jb     14b4 <replaceNWord+0x384>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x0(%r13,%rsi,1),%ecx
mov    %cl,(%rax,%r10,1)
movzbl 0x1(%r13,%rsi,1),%ecx
mov    %cl,0x1(%rax,%r10,1)
movzbl 0x2(%r13,%rsi,1),%ecx
mov    %cl,0x2(%rax,%r10,1)
movzbl 0x3(%r13,%rsi,1),%ecx
mov    %cl,0x3(%rax,%r10,1)
add    $0x4,%r10
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1390 <replaceNWord+0x260>
jmp    14b4 <replaceNWord+0x384>
mov    %rdi,%rbx
add    $0x1,%esi
jmp    128c <replaceNWord+0x15c>
xor    %esi,%esi
jmp    14b7 <replaceNWord+0x387>
cmpq   $0x60,0x48(%rsp)
jae    13eb <replaceNWord+0x2bb>
xor    %esi,%esi
jmp    1461 <replaceNWord+0x331>
mov    0x18(%rsp),%rcx
lea    (%rcx,%r10,1),%rdx
mov    0x20(%rsp),%r11
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,-0x70(%rdx,%rsi,1)
movups %xmm1,-0x60(%rdx,%rsi,1)
movups 0x20(%r13,%rsi,1),%xmm0
movups 0x30(%r13,%rsi,1),%xmm1
movups %xmm0,-0x50(%rdx,%rsi,1)
movups %xmm1,-0x40(%rdx,%rsi,1)
movups 0x40(%r13,%rsi,1),%xmm0
movups 0x50(%r13,%rsi,1),%xmm1
movups %xmm0,-0x30(%rdx,%rsi,1)
movups %xmm1,-0x20(%rdx,%rsi,1)
movups 0x60(%r13,%rsi,1),%xmm0
movups 0x70(%r13,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm1,(%rdx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%r11
jne    1400 <replaceNWord+0x2d0>
cmpq   $0x0,0x40(%rsp)
mov    0x38(%rsp),%r11
je     149b <replaceNWord+0x36b>
mov    0x30(%rsp),%rcx
add    %rsi,%rcx
add    %r10,%rsi
add    0x28(%rsp),%rsi
xor    %edx,%edx
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r11
jne    1480 <replaceNWord+0x350>
mov    0x50(%rsp),%rcx
add    %rcx,%r10
mov    %rcx,%rsi
cmp    %r9,%rcx
mov    0x4(%rsp),%r11d
jne    1344 <replaceNWord+0x214>
mov    %r11d,%esi
mov    0x8(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x8(%rsp)
add    $0x1,%esi
jmp    128c <replaceNWord+0x15c>
xor    %eax,%eax
jmp    14d7 <replaceNWord+0x3a7>
movslq %r10d,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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