#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 */
double fabs(double);
int pow(double, double);
int /*<<< orphan*/ sprintf(char *, char *, double);
int strlen(char *);
void edit_ugmsg(char *s, double fq) {
  double t1;
  int i, j, k, l, m;
  j = strlen(s);
  i = 30 - j - 3;
  i -= i / 3;
  t1 = i;
  t1 = pow(10.0, t1) - 1;
  if (fabs(fq) < t1) {
    sprintf(&s[j], "%.0f Hz", fq);
  } else {
    sprintf(&s[j], "%.0f kHz", fq / 1000);
  }
  i = strlen(s);
  k = i;
  while (s[i] != ' ')
    i--;
  i--;
  j = 0;
  while (s[i - 1] != ' ' && s[i - 1] != '-') {
    j++;
    if (j == 3) {
      k++;
      m = k;
      while (m > i) {
        s[m] = s[m - 1];
        m--;
      }
      s[i] = 39;
      j = 0;
    }
    i--;
  }
  j = 30 - 1;
  i = strlen(s);
  for (l = i; l <= j; l++)
    s[l] = '\x0';
  k = j;
  while (s[k] != 'z')
    k--;
  if (k != j - 1) {
    m = j;
    while (s[m] != '=')
      m--;
    j--;
    for (i = k; i > m; i--) {
      s[j] = s[i];
      s[i] = 32;
      j--;
    }
    for (i = j; i > m; i--) {
      s[i] = 32;
      j--;
    }
  }
}


x86 assembly (clang, -O0):
<edit_ugmsg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x20(%rbp)
mov    $0x1e,%eax
sub    -0x20(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
cvtsi2sdl -0x1c(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  0xe89(%rip),%xmm0
call   1040 <pow@plt>
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x10(%rbp),%xmm1
movaps 0xe5c(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    11d8 <edit_ugmsg+0xa8>
mov    -0x8(%rbp),%rdi
movslq -0x20(%rbp),%rax
add    %rax,%rdi
movsd  -0x10(%rbp),%xmm0
lea    0xe52(%rip),%rsi
call   1050 <sprintf@plt>
jmp    1200 <edit_ugmsg+0xd0>
mov    -0x8(%rbp),%rdi
movslq -0x20(%rbp),%rax
add    %rax,%rdi
movsd  -0x10(%rbp),%xmm0
movsd  0xe28(%rip),%xmm1
divsd  %xmm1,%xmm0
lea    0xe2d(%rip),%rsi
call   1050 <sprintf@plt>
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1235 <edit_ugmsg+0x105>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1212 <edit_ugmsg+0xe2>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x2d(%rbp)
je     127e <edit_ugmsg+0x14e>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
setne  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    128e <edit_ugmsg+0x15e>
jmp    1306 <edit_ugmsg+0x1d6>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jne    12f8 <edit_ugmsg+0x1c8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    12e5 <edit_ugmsg+0x1b5>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b0 <edit_ugmsg+0x180>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x27,(%rax,%rcx,1)
movl   $0x0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1245 <edit_ugmsg+0x115>
movl   $0x1d,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1345 <edit_ugmsg+0x215>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    131f <edit_ugmsg+0x1ef>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
je     136e <edit_ugmsg+0x23e>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    134b <edit_ugmsg+0x21b>
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1436 <edit_ugmsg+0x306>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3d,%eax
je     13a8 <edit_ugmsg+0x278>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1385 <edit_ugmsg+0x255>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    13fc <edit_ugmsg+0x2cc>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    13b7 <edit_ugmsg+0x287>
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    1431 <edit_ugmsg+0x301>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1402 <edit_ugmsg+0x2d2>
jmp    1436 <edit_ugmsg+0x306>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<edit_ugmsg>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x18,%rsp
movaps %xmm0,(%rsp)
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %eax,%ebp
mov    $0x1b,%eax
sub    %ebp,%eax
cltq
imul   $0x55555555,%rax,%rcx
shr    $0x20,%rcx
sub    %eax,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
sar    %ecx
add    %edx,%ecx
add    %eax,%ecx
cvtsi2sd %ecx,%xmm1
movsd  0xe7b(%rip),%xmm0
call   1050 <pow@plt>
movapd (%rsp),%xmm0
add    $0xffffffff,%eax
cvtsi2sd %eax,%xmm2
movapd 0xe72(%rip),%xmm1
andpd  %xmm0,%xmm1
movslq %ebp,%rdi
add    %rbx,%rdi
ucomisd %xmm1,%xmm2
jbe    11b7 <edit_ugmsg+0x77>
lea    0xe7b(%rip),%rsi
jmp    11c6 <edit_ugmsg+0x86>
divsd  0xe49(%rip),%xmm0
lea    0xe72(%rip),%rsi
call   1060 <sprintf@plt>
movabs $0xffffffff00000000,%rbp
ff ff ff
mov    %rbx,%rdi
call   1030 <strlen@plt>
movslq %eax,%rsi
lea    (%rbx,%rsi,1),%rdx
shl    $0x20,%rsi
movabs $0x100000000,%rcx
add    %rsi,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
add    %rbp,%rcx
cmpb   $0x20,(%rdx)
lea    -0x1(%rdx),%rdx
jne    1200 <edit_ugmsg+0xc0>
sar    $0x20,%rcx
mov    %eax,%r8d
jmp    1224 <edit_ugmsg+0xe4>
cs nopw 0x0(%rax,%rax,1)
nop
movb   $0x27,(%rbx,%rcx,1)
add    $0x1,%r8d
mov    -0x2(%rcx,%rbx,1),%dl
cmp    $0x20,%dl
je     1284 <edit_ugmsg+0x144>
cmp    $0x2d,%dl
je     1284 <edit_ugmsg+0x144>
mov    -0x3(%rcx,%rbx,1),%dl
cmp    $0x20,%dl
je     1284 <edit_ugmsg+0x144>
cmp    $0x2d,%dl
je     1284 <edit_ugmsg+0x144>
mov    -0x4(%rcx,%rbx,1),%dl
cmp    $0x20,%dl
je     1284 <edit_ugmsg+0x144>
cmp    $0x2d,%dl
je     1284 <edit_ugmsg+0x144>
lea    -0x2(%rcx),%rsi
add    $0xfffffffffffffffd,%rcx
add    $0x1,%eax
movslq %eax,%rdx
cmp    %rdx,%rsi
jg     1220 <edit_ugmsg+0xe0>
movslq %r8d,%rdi
add    $0x1,%rdi
nopl   0x0(%rax)
movzbl -0x2(%rbx,%rdi,1),%edx
mov    %dl,-0x1(%rbx,%rdi,1)
add    $0xffffffffffffffff,%rdi
cmp    %rsi,%rdi
jg     1270 <edit_ugmsg+0x130>
jmp    1220 <edit_ugmsg+0xe0>
mov    %rbx,%rdi
call   1030 <strlen@plt>
cmp    $0x1d,%eax
jg     12a9 <edit_ugmsg+0x169>
movslq %eax,%rdi
add    %rbx,%rdi
mov    $0x1d,%edx
sub    %eax,%edx
add    $0x1,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
movabs $0x1e00000000,%rsi
xor    %edi,%edi
mov    %rsi,%rcx
nopl   0x0(%rax,%rax,1)
add    %rbp,%rcx
cmpb   $0x7a,0x1d(%rbx,%rdi,1)
lea    -0x1(%rdi),%rdi
jne    12c0 <edit_ugmsg+0x180>
cmp    $0xfffffffe,%edi
je     14ea <edit_ugmsg+0x3aa>
add    $0x1e,%rdi
lea    0x1d(%rbx),%rdx
mov    $0x1f,%r15d
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffff,%r15d
add    %rbp,%rsi
cmpb   $0x3d,(%rdx)
lea    -0x1(%rdx),%rdx
jne    12f0 <edit_ugmsg+0x1b0>
lea    -0x1(%r15),%r11d
mov    $0x1c,%edx
cmp    %r11d,%edi
jle    14c8 <edit_ugmsg+0x388>
sar    $0x20,%rcx
sar    $0x20,%rsi
mov    %rcx,%r8
sub    %rsi,%r8
mov    $0x1c,%edx
cmp    $0x10,%r8
jb     14b0 <edit_ugmsg+0x370>
mov    %rsi,%r10
not    %r10
add    %rcx,%r10
lea    0x1c(%rbx),%r9
mov    %r9,%rbp
sub    %r10,%rbp
cmp    %r9,%rbp
ja     14b0 <edit_ugmsg+0x370>
lea    (%rbx,%rcx,1),%r9
mov    %r9,%rbp
sub    %r10,%rbp
cmp    %r9,%rbp
ja     14b0 <edit_ugmsg+0x370>
mov    %rsi,%rax
sub    %rcx,%rax
add    %rbx,%rax
add    $0x1d,%rax
lea    (%rcx,%rbx,1),%rbp
add    $0x1,%rbp
cmp    %rbp,%rax
jae    138d <edit_ugmsg+0x24d>
lea    0x1d(%rbx),%rax
lea    (%rsi,%rbx,1),%rbp
add    $0x1,%rbp
cmp    %rax,%rbp
jb     14b0 <edit_ugmsg+0x370>
mov    %r8,%r9
and    $0xfffffffffffffff0,%r9
lea    -0x10(%r9),%rax
mov    %rax,%r10
shr    $0x4,%r10
add    $0x1,%r10
cmp    $0x30,%rax
jae    13b0 <edit_ugmsg+0x270>
xor    %ebp,%ebp
jmp    142d <edit_ugmsg+0x2ed>
movslq %edi,%r14
lea    (%rbx,%r14,1),%rdx
add    $0xfffffffffffffff1,%rdx
movslq %r11d,%rax
sub    %rax,%r14
and    $0xfffffffffffffff0,%r14
add    $0xfffffffffffffff0,%r14
shr    $0x4,%r14
add    $0x1,%r14
and    $0xfffffffffffffffc,%r14
xor    %ebp,%ebp
movapd 0xc41(%rip),%xmm0
nop
movups (%rdx,%rbp,1),%xmm1
movups %xmm1,0xd(%rbx,%rbp,1)
movupd %xmm0,(%rdx,%rbp,1)
movups -0x10(%rdx,%rbp,1),%xmm1
movups %xmm1,-0x3(%rbx,%rbp,1)
movupd %xmm0,-0x10(%rdx,%rbp,1)
movups -0x20(%rdx,%rbp,1),%xmm1
movups %xmm1,-0x13(%rbx,%rbp,1)
movupd %xmm0,-0x20(%rdx,%rbp,1)
movupd -0x30(%rdx,%rbp,1),%xmm1
movupd %xmm1,-0x23(%rbx,%rbp,1)
movupd %xmm0,-0x30(%rdx,%rbp,1)
add    $0xffffffffffffffc0,%rbp
add    $0xfffffffffffffffc,%r14
jne    13e0 <edit_ugmsg+0x2a0>
neg    %rbp
mov    $0x1c,%edx
test   $0x3,%r10b
je     149c <edit_ugmsg+0x35c>
mov    %rbx,%r10
sub    %rbp,%r10
movslq %edi,%rax
lea    (%r10,%rax,1),%rdi
add    $0xfffffffffffffff1,%rdi
add    $0xd,%r10
sub    %r15d,%eax
add    $0x1,%al
and    $0x30,%al
add    $0xf0,%al
shr    $0x4,%al
add    $0x1,%al
movzbl %al,%r14d
and    $0x3,%r14d
shl    $0x4,%r14
xor    %ebp,%ebp
movapd 0xbaf(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm1,(%r10,%rbp,1)
movupd %xmm0,(%rdi,%rbp,1)
add    $0xfffffffffffffff0,%rbp
mov    %r14,%rax
add    %rbp,%rax
jne    1480 <edit_ugmsg+0x340>
sub    %r9,%rdx
cmp    %r9,%r8
je     14c8 <edit_ugmsg+0x388>
sub    %r9,%rcx
nopw   0x0(%rax,%rax,1)
movzbl (%rbx,%rcx,1),%eax
mov    %al,(%rbx,%rdx,1)
movb   $0x20,(%rbx,%rcx,1)
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rcx
cmp    %rsi,%rcx
jg     14b0 <edit_ugmsg+0x370>
cmp    %r11d,%edx
jle    14ea <edit_ugmsg+0x3aa>
movslq %edx,%rax
sub    %r15d,%edx
sub    %rdx,%rax
add    %rax,%rbx
add    $0x1,%rdx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1040 <memset@plt>
add    $0x18,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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