int ctrlchar_percent(char *text) {
  char cb, cu, cr;
  float yes, no;
  yes = no = 0.001;
  cb = cu = cr = 0;
  for (; *text; text++) {
    switch (*text) {
    case '\002': {
      cb = (cb) ? 0 : 1;
      break;
    }
    case '\037': {
      cu = (cu) ? 0 : 1;
      break;
    }
    case '\026': {
      cr = (cu) ? 0 : 1;
      break;
    }
    case '\017': {
      cr = cu = cb = 0;
      break;
    }
    default: {
      if (cb || cu || cr)
        yes++;
      else
        no++;
      break;
    }
    }
  }
  return (int)(100 * (yes / (yes + no)));
}


x86 assembly (clang, -O0):
<ctrlchar_percent>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movss  0xef0(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  0xee3(%rip),%xmm0
movss  %xmm0,-0x10(%rbp)
movb   $0x0,-0xb(%rbp)
movb   $0x0,-0xa(%rbp)
movb   $0x0,-0x9(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     122f <ctrlchar_percent+0x12f>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x20(%rbp)
sub    $0x1d,%eax
ja     11c4 <ctrlchar_percent+0xc4>
mov    -0x20(%rbp),%rax
lea    0xead(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movsbl -0x9(%rbp),%edx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,-0x9(%rbp)
jmp    1219 <ctrlchar_percent+0x119>
movsbl -0xa(%rbp),%edx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,-0xa(%rbp)
jmp    1219 <ctrlchar_percent+0x119>
movsbl -0xa(%rbp),%edx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,-0xb(%rbp)
jmp    1219 <ctrlchar_percent+0x119>
movb   $0x0,-0x9(%rbp)
movb   $0x0,-0xa(%rbp)
movb   $0x0,-0xb(%rbp)
jmp    1219 <ctrlchar_percent+0x119>
movsbl -0x9(%rbp),%eax
cmp    $0x0,%eax
jne    11eb <ctrlchar_percent+0xeb>
movsbl -0xa(%rbp),%eax
cmp    $0x0,%eax
jne    11eb <ctrlchar_percent+0xeb>
movsbl -0xb(%rbp),%eax
cmp    $0x0,%eax
je     1202 <ctrlchar_percent+0x102>
movss  0xe15(%rip),%xmm0
addss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x10(%rbp)
jmp    1214 <ctrlchar_percent+0x114>
movss  0xdfe(%rip),%xmm0
addss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
jmp    1219 <ctrlchar_percent+0x119>
jmp    121e <ctrlchar_percent+0x11e>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    112e <ctrlchar_percent+0x2e>
movss  -0x10(%rbp),%xmm1
movss  -0x10(%rbp),%xmm0
addss  -0x14(%rbp),%xmm0
divss  %xmm0,%xmm1
movss  0xdba(%rip),%xmm0
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<ctrlchar_percent>:
mov    (%rdi),%cl
test   %cl,%cl
je     11ce <ctrlchar_percent+0xce>
add    $0x1,%rdi
movss  0xeea(%rip),%xmm0
xor    %r10d,%r10d
movss  0xee3(%rip),%xmm2
lea    0xee4(%rip),%r8
movaps %xmm0,%xmm1
xor    %esi,%esi
xor    %edx,%edx
jmp    1164 <ctrlchar_percent+0x64>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %sil,%sil
sete   %al
mov    %edx,%r9d
mov    %esi,%r11d
nopl   0x0(%rax)
movzbl (%rdi),%ecx
add    $0x1,%rdi
mov    %eax,%r10d
mov    %r11d,%esi
mov    %r9d,%edx
test   %cl,%cl
je     11d9 <ctrlchar_percent+0xd9>
movsbl %cl,%eax
add    $0xfffffffe,%eax
cmp    $0x1d,%eax
ja     1190 <ctrlchar_percent+0x90>
xor    %r9d,%r9d
movslq (%r8,%rax,4),%rcx
add    %r8,%rcx
xor    %r11d,%r11d
xor    %eax,%eax
jmp    *%rcx
test   %dl,%dl
sete   %r9b
jmp    11c6 <ctrlchar_percent+0xc6>
nopl   0x0(%rax,%rax,1)
test   %dl,%dl
jne    11bf <ctrlchar_percent+0xbf>
test   %sil,%sil
jne    11bf <ctrlchar_percent+0xbf>
test   %r10b,%r10b
jne    11bf <ctrlchar_percent+0xbf>
addss  %xmm2,%xmm0
xor    %r9d,%r9d
xor    %r11d,%r11d
xor    %eax,%eax
jmp    1150 <ctrlchar_percent+0x50>
nopl   0x0(%rax)
test   %sil,%sil
sete   %r11b
mov    %edx,%r9d
mov    %r10d,%eax
jmp    1150 <ctrlchar_percent+0x50>
addss  %xmm2,%xmm1
mov    %edx,%r9d
mov    %esi,%r11d
mov    %r10d,%eax
jmp    1150 <ctrlchar_percent+0x50>
movss  0xe2a(%rip),%xmm1
movaps %xmm1,%xmm0
addss  %xmm1,%xmm0
divss  %xmm0,%xmm1
mulss  0xe1f(%rip),%xmm1
cvttss2si %xmm1,%eax
ret

LLVM IR (-O0):
define i32 @ctrlchar_percent(i8* %0) {
%2 = alloca i8*
%3 = alloca i8
%4 = alloca i8
%5 = alloca i8
%6 = alloca float
%7 = alloca float
store i8* %0, i8** %2
store float 0x3F50624DE0000000, float* %7
store float 0x3F50624DE0000000, float* %6
store i8 0, i8* %5
store i8 0, i8* %4
store i8 0, i8* %3
br label %8
8: ; preds = %58, %1
%9 = load i8*, i8** %2
%10 = load i8, i8* %9
%11 = icmp ne i8 %10, 0
br i1 %11, label %12, label %61
12: ; preds = %8
%13 = load i8*, i8** %2
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
switch i32 %15, label %38 [
i32 2, label %16
i32 31, label %23
i32 22, label %30
i32 15, label %37
]
16: ; preds = %12
%17 = load i8, i8* %3
%18 = sext i8 %17 to i32
%19 = icmp ne i32 %18, 0
%20 = zext i1 %19 to i64
%21 = select i1 %19, i32 0, i32 1
%22 = trunc i32 %21 to i8
store i8 %22, i8* %3
br label %57
23: ; preds = %12
%24 = load i8, i8* %4
%25 = sext i8 %24 to i32
%26 = icmp ne i32 %25, 0
%27 = zext i1 %26 to i64
%28 = select i1 %26, i32 0, i32 1
%29 = trunc i32 %28 to i8
store i8 %29, i8* %4
br label %57
30: ; preds = %12
%31 = load i8, i8* %4
%32 = sext i8 %31 to i32
%33 = icmp ne i32 %32, 0
%34 = zext i1 %33 to i64
%35 = select i1 %33, i32 0, i32 1
%36 = trunc i32 %35 to i8
store i8 %36, i8* %5
br label %57
37: ; preds = %12
store i8 0, i8* %3
store i8 0, i8* %4
store i8 0, i8* %5
br label %57
38: ; preds = %12
%39 = load i8, i8* %3
%40 = sext i8 %39 to i32
%41 = icmp ne i32 %40, 0
br i1 %41, label %50, label %42
42: ; preds = %38
%43 = load i8, i8* %4
%44 = sext i8 %43 to i32
%45 = icmp ne i32 %44, 0
br i1 %45, label %50, label %46
46: ; preds = %42
%47 = load i8, i8* %5
%48 = sext i8 %47 to i32
%49 = icmp ne i32 %48, 0
br i1 %49, label %50, label %53
50: ; preds = %46, %42, %38
%51 = load float, float* %6
%52 = fadd float %51, 1.000000e+00
store float %52, float* %6
br label %56
53: ; preds = %46
%54 = load float, float* %7
%55 = fadd float %54, 1.000000e+00
store float %55, float* %7
br label %56
56: ; preds = %53, %50
br label %57
57: ; preds = %56, %37, %30, %23, %16
br label %58
58: ; preds = %57
%59 = load i8*, i8** %2
%60 = getelementptr inbounds i8, i8* %59, i32 1
store i8* %60, i8** %2
br label %8
61: ; preds = %8
%62 = load float, float* %6
%63 = load float, float* %6
%64 = load float, float* %7
%65 = fadd float %63, %64
%66 = fdiv float %62, %65
%67 = fmul float 1.000000e+02, %66
%68 = fptosi float %67 to i32
ret i32 %68
}

LLVM IR (-O2):
define i32 @ctrlchar_percent(i8* nocapture %0) {
%2 = load i8, i8* %0
%3 = icmp eq i8 %2, 0
br i1 %3, label %41, label %4
4: ; preds = %1, %32
%5 = phi i8 [ %39, %32 ], [ %2, %1 ]
%6 = phi float [ %37, %32 ], [ 0x3F50624DE0000000, %1 ]
%7 = phi float [ %36, %32 ], [ 0x3F50624DE0000000, %1 ]
%8 = phi i8 [ %35, %32 ], [ 0, %1 ]
%9 = phi i8 [ %34, %32 ], [ 0, %1 ]
%10 = phi i8 [ %33, %32 ], [ 0, %1 ]
%11 = phi i8* [ %38, %32 ], [ %0, %1 ]
%12 = sext i8 %5 to i32
switch i32 %12, label %22 [
i32 2, label %13
i32 31, label %16
i32 22, label %19
i32 15, label %32
]
13: ; preds = %4
%14 = icmp eq i8 %10, 0
%15 = zext i1 %14 to i8
br label %32
16: ; preds = %4
%17 = icmp eq i8 %9, 0
%18 = zext i1 %17 to i8
br label %32
19: ; preds = %4
%20 = icmp eq i8 %9, 0
%21 = zext i1 %20 to i8
br label %32
22: ; preds = %4
%23 = icmp ne i8 %10, 0
%24 = icmp ne i8 %9, 0
%25 = select i1 %23, i1 true, i1 %24
%26 = icmp ne i8 %8, 0
%27 = select i1 %25, i1 true, i1 %26
br i1 %27, label %28, label %30
28: ; preds = %22
%29 = fadd float %7, 1.000000e+00
br label %32
30: ; preds = %22
%31 = fadd float %6, 1.000000e+00
br label %32
32: ; preds = %4, %13, %16, %19, %30, %28
%33 = phi i8 [ %10, %28 ], [ 0, %30 ], [ %10, %19 ], [ %10, %16 ], [ %15, %13 ], [ 0, %4 ]
%34 = phi i8 [ %9, %28 ], [ 0, %30 ], [ %9, %19 ], [ %18, %16 ], [ %9, %13 ], [ 0, %4 ]
%35 = phi i8 [ %8, %28 ], [ 0, %30 ], [ %21, %19 ], [ %8, %16 ], [ %8, %13 ], [ 0, %4 ]
%36 = phi float [ %29, %28 ], [ %7, %30 ], [ %7, %19 ], [ %7, %16 ], [ %7, %13 ], [ %7, %4 ]
%37 = phi float [ %6, %28 ], [ %31, %30 ], [ %6, %19 ], [ %6, %16 ], [ %6, %13 ], [ %6, %4 ]
%38 = getelementptr inbounds i8, i8* %11, i64 1
%39 = load i8, i8* %38
%40 = icmp eq i8 %39, 0
br i1 %40, label %41, label %4
41: ; preds = %32, %1
%42 = phi float [ 0x3F50624DE0000000, %1 ], [ %36, %32 ]
%43 = phi float [ 0x3F50624DE0000000, %1 ], [ %37, %32 ]
%44 = fadd float %42, %43
%45 = fdiv float %42, %44
%46 = fmul float %45, 1.000000e+02
%47 = fptosi float %46 to i32
ret i32 %47
}