#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*/ ansi_transition_esccode(int, int);
char *pool_alloc(int, char *);
int /*<<< orphan*/ safe_copy_chr(char, char *, char **, int);
int /*<<< orphan*/ safe_copy_str(int /*<<< orphan*/, char *, char **, int);
int /*<<< orphan*/ safe_known_str(char *, int, char *, char **);
int /*<<< orphan*/ strcmp(char *, char *);
int strlen(char *);
int /*<<< orphan*/ strncmp(char *, char *, int);
int /*<<< orphan*/ track_all_esccodes(char **, char **, int *);
int /*<<< orphan*/ track_esccode(char **, int *);
void edit_string(char *src, char **dst, char *from, char *to) {
  char *cp, *p;
  int ansi_state, to_ansi_set, to_ansi_clr, tlen, flen;
  p = from + strlen(from) - 4;
  if (p >= from && !strcmp(p, "\033[0m")) {
    *p = '\0';
  }
  p = to + strlen(to) - 4;
  if (p >= to && !strcmp(p, "\033[0m")) {
    *p = '\0';
  }
  ansi_state = 0x1099;
  track_all_esccodes(&to, &p, &ansi_state);
  to_ansi_set = (~0x1099) & ansi_state;
  to_ansi_clr = 0x1099 & (~ansi_state);
  tlen = p - to;
  cp = *dst = pool_alloc(2, "edit_string");
  if (!strcmp(from, "^")) {
    safe_known_str(to, tlen, *dst, &cp);
    track_all_esccodes(&src, &p, &ansi_state);
    safe_known_str(src, p - src, *dst, &cp);
  } else if (!strcmp(from, "$")) {
    ansi_state = 0x1099;
    track_all_esccodes(&src, &p, &ansi_state);
    safe_known_str(src, p - src, *dst, &cp);
    ansi_state |= to_ansi_set;
    ansi_state &= ~to_ansi_clr;
    safe_known_str(to, tlen, *dst, &cp);
  } else {
    if (((from[0] == '\\') || (from[0] == '%')) &&
        ((from[1] == '$') || (from[1] == '^')) && (from[2] == '\0')) {
      from++;
    }
    flen = strlen(from);
    ansi_state = 0x1099;
    while (*src) {
      p = src;
      while (*src && (*src != *from)) {
        if (*src == '\033') {
          track_esccode(&src, &ansi_state);
        } else {
          ++src;
        }
      }
      safe_known_str(p, src - p, *dst, &cp);
      if (*src) {
        if (!strncmp(from, src, flen)) {
          ansi_state |= to_ansi_set;
          ansi_state &= ~to_ansi_clr;
          safe_known_str(to, tlen, *dst, &cp);
          src += flen;
        } else {
          if (*from == '\033') {
            p = src;
            track_esccode(&src, &ansi_state);
            safe_known_str(p, src - p, *dst, &cp);
          } else {
            safe_copy_chr((*src), (*dst), (&cp), (8192 - 1));
            ++src;
          }
        }
      }
    }
  }
  safe_copy_str((ansi_transition_esccode(ansi_state, 0x1099)), (*dst), (&cp),
                (8192 - 1));
}


x86 assembly (clang, -O0):
<edit_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     120b <edit_string+0x6b>
mov    -0x30(%rbp),%rdi
lea    0xe0a(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%eax
jne    120b <edit_string+0x6b>
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jb     125e <edit_string+0xbe>
mov    -0x30(%rbp),%rdi
lea    0xdb7(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%eax
jne    125e <edit_string+0xbe>
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x1099,-0x34(%rbp)
lea    -0x20(%rbp),%rdi
lea    -0x30(%rbp),%rsi
lea    -0x34(%rbp),%rdx
call   10a0 <track_all_esccodes@plt>
mov    -0x34(%rbp),%eax
and    $0xffffef66,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
xor    $0xffffffff,%eax
and    $0x1099,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x40(%rbp)
mov    $0x2,%edi
lea    0xd5c(%rip),%rsi
call   1040 <pool_alloc@plt>
mov    -0x10(%rbp),%rcx
mov    %rax,(%rcx)
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
lea    0xd4d(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%eax
jne    1320 <edit_string+0x180>
mov    -0x20(%rbp),%rdi
mov    -0x40(%rbp),%esi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    -0x28(%rbp),%rcx
call   1070 <safe_known_str@plt>
lea    -0x8(%rbp),%rdi
lea    -0x30(%rbp),%rsi
lea    -0x34(%rbp),%rdx
call   10a0 <track_all_esccodes@plt>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%esi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    -0x28(%rbp),%rcx
call   1070 <safe_known_str@plt>
jmp    15af <edit_string+0x40f>
mov    -0x18(%rbp),%rdi
lea    0xce8(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%eax
jne    13a3 <edit_string+0x203>
movl   $0x1099,-0x34(%rbp)
lea    -0x8(%rbp),%rdi
lea    -0x30(%rbp),%rsi
lea    -0x34(%rbp),%rdx
call   10a0 <track_all_esccodes@plt>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%esi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    -0x28(%rbp),%rcx
call   1070 <safe_known_str@plt>
mov    -0x38(%rbp),%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
xor    $0xffffffff,%eax
and    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x40(%rbp),%esi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    -0x28(%rbp),%rcx
call   1070 <safe_known_str@plt>
jmp    15aa <edit_string+0x40a>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
je     13c3 <edit_string+0x223>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x25,%eax
jne    1402 <edit_string+0x262>
mov    -0x18(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x24,%eax
je     13e5 <edit_string+0x245>
mov    -0x18(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x5e,%eax
jne    1402 <edit_string+0x262>
mov    -0x18(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x0,%eax
jne    1402 <edit_string+0x262>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x44(%rbp)
movl   $0x1099,-0x34(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     15a5 <edit_string+0x405>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x59(%rbp)
je     1455 <edit_string+0x2b5>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    -0x18(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    1465 <edit_string+0x2c5>
jmp    1498 <edit_string+0x2f8>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x1b,%eax
jne    1487 <edit_string+0x2e7>
lea    -0x8(%rbp),%rdi
lea    -0x34(%rbp),%rsi
call   1060 <track_esccode@plt>
jmp    1493 <edit_string+0x2f3>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    142a <edit_string+0x28a>
mov    -0x30(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%esi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    -0x28(%rbp),%rcx
call   1070 <safe_known_str@plt>
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     15a0 <edit_string+0x400>
mov    -0x18(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x44(%rbp),%edx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    1521 <edit_string+0x381>
mov    -0x38(%rbp),%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
xor    $0xffffffff,%eax
and    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x40(%rbp),%esi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    -0x28(%rbp),%rcx
call   1070 <safe_known_str@plt>
mov    -0x44(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    159b <edit_string+0x3fb>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x1b,%eax
jne    156c <edit_string+0x3cc>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
lea    -0x8(%rbp),%rdi
lea    -0x34(%rbp),%rsi
call   1060 <track_esccode@plt>
mov    -0x30(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%esi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    -0x28(%rbp),%rcx
call   1070 <safe_known_str@plt>
jmp    1596 <edit_string+0x3f6>
mov    -0x8(%rbp),%rax
mov    (%rax),%al
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rsi
lea    -0x28(%rbp),%rdx
mov    $0x1fff,%ecx
movsbl %al,%edi
call   1090 <safe_copy_chr@plt>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    159b <edit_string+0x3fb>
jmp    15a0 <edit_string+0x400>
jmp    1415 <edit_string+0x275>
jmp    15aa <edit_string+0x40a>
jmp    15af <edit_string+0x40f>
mov    -0x34(%rbp),%edi
mov    $0x1099,%esi
call   10c0 <ansi_transition_esccode@plt>
mov    %eax,%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    -0x28(%rbp),%rdx
mov    $0x1fff,%ecx
call   10b0 <safe_copy_str@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<edit_string>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%r15
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%rbp
mov    %rdi,0x10(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rdx,%rdi
call   1050 <strlen@plt>
cltq
lea    (%rbx,%rax,1),%r12
add    $0xfffffffffffffffc,%r12
cmp    %rbx,%r12
jb     11f3 <edit_string+0x53>
lea    0xe1e(%rip),%rsi
mov    %r12,%rdi
call   1080 <strcmp@plt>
test   %eax,%eax
jne    11f3 <edit_string+0x53>
movb   $0x0,(%r12)
mov    %r15,%rdi
call   1050 <strlen@plt>
cltq
lea    (%r15,%rax,1),%r12
add    $0xfffffffffffffffc,%r12
mov    %r12,0x18(%rsp)
cmp    %r15,%r12
jb     1227 <edit_string+0x87>
lea    0xdea(%rip),%rsi
mov    %r12,%rdi
call   1080 <strcmp@plt>
test   %eax,%eax
jne    1227 <edit_string+0x87>
movb   $0x0,(%r12)
movl   $0x1099,0xc(%rsp)
lea    0x28(%rsp),%rdi
lea    0x18(%rsp),%rsi
lea    0xc(%rsp),%rdx
call   10a0 <track_all_esccodes@plt>
mov    0xc(%rsp),%r13d
mov    0x18(%rsp),%r12d
sub    0x28(%rsp),%r12d
lea    0xdac(%rip),%rsi
mov    $0x2,%edi
call   1040 <pool_alloc@plt>
mov    %rax,%r15
mov    %rax,(%r14)
mov    %rax,0x20(%rsp)
lea    0xd9c(%rip),%rsi
mov    %rbx,%rdi
call   1080 <strcmp@plt>
test   %eax,%eax
je     1443 <edit_string+0x2a3>
mov    %r13d,%r15d
and    $0xffffef66,%r15d
lea    0xd7d(%rip),%rsi
mov    %rbx,%rdi
call   1080 <strcmp@plt>
test   %eax,%eax
je     147f <edit_string+0x2df>
mov    (%rbx),%al
cmp    $0x5c,%al
mov    %r12d,0x3c(%rsp)
mov    %r13d,0x34(%rsp)
mov    %r15d,0x38(%rsp)
je     12bf <edit_string+0x11f>
cmp    $0x25,%al
jne    12d6 <edit_string+0x136>
mov    0x1(%rbx),%al
cmp    $0x5e,%al
je     12ca <edit_string+0x12a>
cmp    $0x24,%al
jne    12d6 <edit_string+0x136>
lea    0x1(%rbx),%rax
cmpb   $0x0,0x2(%rbx)
cmove  %rax,%rbx
mov    %rbx,%rdi
call   1050 <strlen@plt>
movl   $0x1099,0xc(%rsp)
cmpb   $0x0,0x0(%rbp)
je     14dd <edit_string+0x33d>
mov    %eax,%r12d
orl    $0xffffef66,0x34(%rsp)
ff
cltq
mov    %rax,0x40(%rsp)
lea    0x10(%rsp),%r15
lea    0xc(%rsp),%r13
jmp    134f <edit_string+0x1af>
xchg   %ax,%ax
mov    0xc(%rsp),%eax
or     0x38(%rsp),%eax
and    0x34(%rsp),%eax
mov    %eax,0xc(%rsp)
mov    0x28(%rsp),%rdi
mov    (%r14),%rdx
mov    0x3c(%rsp),%esi
lea    0x20(%rsp),%rcx
call   1070 <safe_known_str@plt>
mov    0x10(%rsp),%rbp
add    0x40(%rsp),%rbp
mov    %rbp,0x10(%rsp)
cmpb   $0x0,0x0(%rbp)
je     14dd <edit_string+0x33d>
mov    %rbp,0x18(%rsp)
mov    0x0(%rbp),%al
test   %al,%al
jne    1371 <edit_string+0x1d1>
mov    %rbp,%rsi
jmp    1398 <edit_string+0x1f8>
add    $0x1,%rbp
mov    %rbp,0x10(%rsp)
movzbl 0x0(%rbp),%eax
test   %al,%al
je     1390 <edit_string+0x1f0>
cmp    (%rbx),%al
je     1390 <edit_string+0x1f0>
cmp    $0x1b,%al
jne    1360 <edit_string+0x1c0>
mov    %r15,%rdi
mov    %r13,%rsi
call   1060 <track_esccode@plt>
mov    0x10(%rsp),%rbp
jmp    1369 <edit_string+0x1c9>
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rsi
mov    0x18(%rsp),%rbp
sub    %ebp,%esi
mov    (%r14),%rdx
mov    %rbp,%rdi
lea    0x20(%rsp),%rcx
call   1070 <safe_known_str@plt>
mov    0x10(%rsp),%rsi
cmpb   $0x0,(%rsi)
je     14dd <edit_string+0x33d>
mov    %rbx,%rdi
mov    %r12d,%edx
call   1030 <strncmp@plt>
test   %eax,%eax
je     1310 <edit_string+0x170>
cmpb   $0x1b,(%rbx)
mov    0x10(%rsp),%rax
jne    1420 <edit_string+0x280>
mov    %rax,0x18(%rsp)
mov    %r15,%rdi
mov    %r13,%rsi
call   1060 <track_esccode@plt>
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%esi
sub    %edi,%esi
mov    (%r14),%rdx
lea    0x20(%rsp),%rcx
call   1070 <safe_known_str@plt>
mov    0x10(%rsp),%rbp
cmpb   $0x0,0x0(%rbp)
jne    134f <edit_string+0x1af>
jmp    14dd <edit_string+0x33d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbl (%rax),%edi
mov    (%r14),%rsi
lea    0x20(%rsp),%rdx
mov    $0x1fff,%ecx
call   1090 <safe_copy_chr@plt>
mov    0x10(%rsp),%rbp
add    $0x1,%rbp
jmp    1340 <edit_string+0x1a0>
mov    0x28(%rsp),%rdi
lea    0x20(%rsp),%rbx
mov    %r12d,%esi
mov    %r15,%rdx
mov    %rbx,%rcx
call   1070 <safe_known_str@plt>
lea    0x10(%rsp),%rdi
lea    0x18(%rsp),%rsi
lea    0xc(%rsp),%rdx
call   10a0 <track_all_esccodes@plt>
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%esi
sub    %edi,%esi
mov    (%r14),%rdx
jmp    14d5 <edit_string+0x335>
movl   $0x1099,0xc(%rsp)
lea    0x10(%rsp),%rdi
lea    0x18(%rsp),%rsi
lea    0xc(%rsp),%rdx
call   10a0 <track_all_esccodes@plt>
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%esi
sub    %edi,%esi
mov    (%r14),%rdx
lea    0x20(%rsp),%rbx
mov    %rbx,%rcx
call   1070 <safe_known_str@plt>
or     0xc(%rsp),%r15d
or     $0xffffef66,%r13d
and    %r15d,%r13d
mov    %r13d,0xc(%rsp)
mov    0x28(%rsp),%rdi
mov    (%r14),%rdx
mov    %r12d,%esi
mov    %rbx,%rcx
call   1070 <safe_known_str@plt>
mov    0xc(%rsp),%edi
mov    $0x1099,%esi
call   10c0 <ansi_transition_esccode@plt>
mov    (%r14),%rsi
lea    0x20(%rsp),%rdx
mov    %eax,%edi
mov    $0x1fff,%ecx
call   10b0 <safe_copy_str@plt>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [5 x i8] c"\1B[0m\00"
@.str.1 = [12 x i8] c"edit_string\00"
@.str.2 = [2 x i8] c"^\00"
@.str.3 = [2 x i8] c"$\00"
define void @edit_string(i8* %0, i8** nocapture %1, i8* %2, i8* %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
store i8* %0, i8** %5
store i8* %3, i8** %6
%10 = bitcast i8** %7 to i8*
%11 = bitcast i8** %8 to i8*
%12 = bitcast i32* %9 to i8*
%13 = tail call i32 @strlen(i8* %2)
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i8, i8* %2, i64 %14
%16 = getelementptr inbounds i8, i8* %15, i64 -4
%17 = icmp ult i8* %16, %2
br i1 %17, label %22, label %18
18: ; preds = %4
%19 = tail call i32 @strcmp(i8* %16, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%20 = icmp eq i32 %19, 0
br i1 %20, label %21, label %22
21: ; preds = %18
store i8 0, i8* %16
br label %22
22: ; preds = %21, %18, %4
%23 = tail call i32 @strlen(i8* %3)
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %3, i64 %24
%26 = getelementptr inbounds i8, i8* %25, i64 -4
store i8* %26, i8** %8
%27 = icmp ult i8* %26, %3
br i1 %27, label %32, label %28
28: ; preds = %22
%29 = tail call i32 @strcmp(i8* %26, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%30 = icmp eq i32 %29, 0
br i1 %30, label %31, label %32
31: ; preds = %28
store i8 0, i8* %26
br label %32
32: ; preds = %31, %28, %22
store i32 4249, i32* %9
%33 = call i32 @track_all_esccodes(i8** %6, i8** %8, i32* %9)
%34 = load i32, i32* %9
%35 = and i32 %34, -4250
%36 = load i8*, i8** %8
%37 = load i8*, i8** %6
%38 = ptrtoint i8* %36 to i64
%39 = ptrtoint i8* %37 to i64
%40 = sub i64 %38, %39
%41 = trunc i64 %40 to i32
%42 = call i8* @pool_alloc(i32 2, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0))
store i8* %42, i8** %1
store i8* %42, i8** %7
%43 = call i32 @strcmp(i8* dereferenceable(1) %2, i8* dereferenceable(2) getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%44 = icmp eq i32 %43, 0
br i1 %44, label %45, label %57
45: ; preds = %32
%46 = load i8*, i8** %6
%47 = call i32 @safe_known_str(i8* %46, i32 %41, i8* %42, i8** %7)
%48 = call i32 @track_all_esccodes(i8** %5, i8** %8, i32* %9)
%49 = load i8*, i8** %5
%50 = load i8*, i8** %8
%51 = ptrtoint i8* %50 to i64
%52 = ptrtoint i8* %49 to i64
%53 = sub i64 %51, %52
%54 = trunc i64 %53 to i32
%55 = load i8*, i8** %1
%56 = call i32 @safe_known_str(i8* %49, i32 %54, i8* %55, i8** %7)
br label %167
57: ; preds = %32
%58 = call i32 @strcmp(i8* dereferenceable(1) %2, i8* dereferenceable(2) getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%59 = icmp eq i32 %58, 0
br i1 %59, label %60, label %77
60: ; preds = %57
store i32 4249, i32* %9
%61 = call i32 @track_all_esccodes(i8** %5, i8** %8, i32* %9)
%62 = load i8*, i8** %5
%63 = load i8*, i8** %8
%64 = ptrtoint i8* %63 to i64
%65 = ptrtoint i8* %62 to i64
%66 = sub i64 %64, %65
%67 = trunc i64 %66 to i32
%68 = load i8*, i8** %1
%69 = call i32 @safe_known_str(i8* %62, i32 %67, i8* %68, i8** %7)
%70 = load i32, i32* %9
%71 = or i32 %70, %35
%72 = or i32 %34, -4250
%73 = and i32 %71, %72
store i32 %73, i32* %9
%74 = load i8*, i8** %6
%75 = load i8*, i8** %1
%76 = call i32 @safe_known_str(i8* %74, i32 %41, i8* %75, i8** %7)
br label %167
77: ; preds = %57
%78 = load i8, i8* %2
switch i8 %78, label %87 [
i8 92, label %79
i8 37, label %79
]
79: ; preds = %77, %77
%80 = getelementptr inbounds i8, i8* %2, i64 1
%81 = load i8, i8* %80
switch i8 %81, label %87 [
i8 36, label %82
i8 94, label %82
]
82: ; preds = %79, %79
%83 = getelementptr inbounds i8, i8* %2, i64 2
%84 = load i8, i8* %83
%85 = icmp eq i8 %84, 0
%86 = select i1 %85, i8* %80, i8* %2
br label %87
87: ; preds = %82, %79, %77
%88 = phi i8* [ %2, %77 ], [ %2, %79 ], [ %86, %82 ]
%89 = call i32 @strlen(i8* %88)
store i32 4249, i32* %9
%90 = load i8, i8* %0
%91 = icmp eq i8 %90, 0
br i1 %91, label %167, label %92
92: ; preds = %87
%93 = or i32 %34, -4250
%94 = sext i32 %89 to i64
br label %95
95: ; preds = %92, %163
%96 = phi i8* [ %0, %92 ], [ %164, %163 ]
store i8* %96, i8** %8
%97 = load i8, i8* %96
%98 = icmp eq i8 %97, 0
br i1 %98, label %118, label %99
99: ; preds = %95, %111
%100 = phi i8 [ %113, %111 ], [ %97, %95 ]
%101 = phi i8* [ %112, %111 ], [ %96, %95 ]
%102 = load i8, i8* %88
%103 = icmp eq i8 %100, %102
br i1 %103, label %115, label %104
104: ; preds = %99
%105 = icmp eq i8 %100, 27
br i1 %105, label %106, label %109
106: ; preds = %104
%107 = call i32 @track_esccode(i8** %5, i32* %9)
%108 = load i8*, i8** %5
br label %111
109: ; preds = %104
%110 = getelementptr inbounds i8, i8* %101, i64 1
store i8* %110, i8** %5
br label %111
111: ; preds = %109, %106
%112 = phi i8* [ %110, %109 ], [ %108, %106 ]
%113 = load i8, i8* %112
%114 = icmp eq i8 %113, 0
br i1 %114, label %115, label %99
115: ; preds = %111, %99
%116 = phi i8* [ %101, %99 ], [ %112, %111 ]
%117 = load i8*, i8** %8
br label %118
118: ; preds = %115, %95
%119 = phi i8* [ %96, %95 ], [ %117, %115 ]
%120 = phi i8* [ %96, %95 ], [ %116, %115 ]
%121 = ptrtoint i8* %120 to i64
%122 = ptrtoint i8* %119 to i64
%123 = sub i64 %121, %122
%124 = trunc i64 %123 to i32
%125 = load i8*, i8** %1
%126 = call i32 @safe_known_str(i8* %119, i32 %124, i8* %125, i8** %7)
%127 = load i8*, i8** %5
%128 = load i8, i8* %127
%129 = icmp eq i8 %128, 0
br i1 %129, label %167, label %130
130: ; preds = %118
%131 = call i32 @strncmp(i8* %88, i8* %127, i32 %89)
%132 = icmp eq i32 %131, 0
br i1 %132, label %133, label %142
133: ; preds = %130
%134 = load i32, i32* %9
%135 = or i32 %134, %35
%136 = and i32 %135, %93
store i32 %136, i32* %9
%137 = load i8*, i8** %6
%138 = load i8*, i8** %1
%139 = call i32 @safe_known_str(i8* %137, i32 %41, i8* %138, i8** %7)
%140 = load i8*, i8** %5
%141 = getelementptr inbounds i8, i8* %140, i64 %94
store i8* %141, i8** %5
br label %163
142: ; preds = %130
%143 = load i8, i8* %88
%144 = icmp eq i8 %143, 27
%145 = load i8*, i8** %5
br i1 %144, label %146, label %157
146: ; preds = %142
store i8* %145, i8** %8
%147 = call i32 @track_esccode(i8** %5, i32* %9)
%148 = load i8*, i8** %8
%149 = load i8*, i8** %5
%150 = ptrtoint i8* %149 to i64
%151 = ptrtoint i8* %148 to i64
%152 = sub i64 %150, %151
%153 = trunc i64 %152 to i32
%154 = load i8*, i8** %1
%155 = call i32 @safe_known_str(i8* %148, i32 %153, i8* %154, i8** %7)
%156 = load i8*, i8** %5
br label %163
157: ; preds = %142
%158 = load i8, i8* %145
%159 = load i8*, i8** %1
%160 = call i32 @safe_copy_chr(i8 signext %158, i8* %159, i8** %7, i32 8191)
%161 = load i8*, i8** %5
%162 = getelementptr inbounds i8, i8* %161, i64 1
store i8* %162, i8** %5
br label %163
163: ; preds = %133, %157, %146
%164 = phi i8* [ %156, %146 ], [ %162, %157 ], [ %141, %133 ]
%165 = load i8, i8* %164
%166 = icmp eq i8 %165, 0
br i1 %166, label %167, label %95
167: ; preds = %118, %163, %87, %60, %45
%168 = load i32, i32* %9
%169 = call i32 @ansi_transition_esccode(i32 %168, i32 4249)
%170 = load i8*, i8** %1
%171 = call i32 @safe_copy_str(i32 %169, i8* %170, i8** %7, i32 8191)
ret void
}