user: 请从给定的汇编指令推导出C源代码:

```asm
<pretraducir>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x28,%rsp
  mov    %rdi,0x8(%rsp)
  mov    %rsi,%r14
  movzbl (%rdi),%r13d
  test   %r13b,%r13b
  je     L914
  mov    %rdi,%rbx
  mov    $0x0,%ebp
  mov    $0x0,%r12d
  lea    D287(%rip),%r15
  jmp    L380
L743:
  add    $0x1,%r12d
  mov    %r12d,%r13d
  add    0x8(%rsp),%r13
  movsbl 0x0(%r13),%edi
  mov    $0x0,%eax
  call   <esOperador@plt>
  test   %eax,%eax
  jne    L799
  movzbl 0x0(%r13),%eax
  mov    %eax,%edx
  and    $0xfffffff7,%edx
  cmp    $0x21,%dl
  je     L799
  test   %al,%al
  jne    L99
L799:
  movzbl (%rbx),%edx
  mov    %ebp,%eax
  mov    %dl,(%r14,%rax,1)
  lea    0x1(%rbp),%ebp
  jmp    L609
L99:
  lea    0x1(%rbp),%eax
  movzbl (%rbx),%ecx
  mov    %ebp,%edx
  mov    %cl,(%r14,%rdx,1)
  add    $0x2,%ebp
  mov    %eax,%eax
  movb   $0x2a,(%r14,%rax,1)
  jmp    L609
L860:
  mov    %ebp,%eax
  add    %r14,%rax
  movl   $0x43736572,(%rax)
  movw   $0x6d6f,0x4(%rax)
  movb   $0x70,0x6(%rax)
  add    $0x7,%ebp
  add    $0x7,%r12d
  jmp    L609
L257:
  mov    %ebp,%eax
  add    %r14,%rax
  movw   $0x6572,(%rax)
  movb   $0x73,0x2(%rax)
  add    $0x3,%ebp
  add    $0x3,%r12d
L609:
  mov    %r12d,%ebx
  add    0x8(%rsp),%rbx
  movzbl (%rbx),%r13d
  test   %r13b,%r13b
  je     L611
L380:
  cmp    $0x69,%r13b
  je     L743
  mov    $0x7,%edx
  mov    %r15,%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  je     L860
  mov    $0x3,%edx
  lea    D30(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  je     L257
  mov    $0x3,%edx
  lea    D119(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  je     L257
  mov    $0x4,%edx
  lea    D140(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L112
  mov    %ebp,%eax
  movb   $0x61,(%r14,%rax,1)
  add    $0x4,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L112:
  mov    $0x3,%edx
  lea    D175(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  je     L729
  mov    $0x3,%edx
  lea    D83(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L910
L729:
  mov    %ebp,%eax
  movb   $0x62,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L910:
  mov    $0x3,%edx
  lea    D148(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L216
  mov    %ebp,%eax
  movb   $0x63,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L216:
  mov    $0x3,%edx
  lea    D254(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L396
  mov    %ebp,%eax
  movb   $0x64,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L396:
  mov    $0x4,%edx
  lea    D70(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  je     L761
  mov    $0x4,%edx
  lea    D130(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L601
L761:
  mov    %ebp,%eax
  movb   $0x65,(%r14,%rax,1)
  add    $0x4,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L601:
  mov    $0x4,%edx
  lea    D69(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L679
  mov    %ebp,%eax
  movb   $0x66,(%r14,%rax,1)
  add    $0x4,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L679:
  mov    $0x4,%edx
  lea    D193(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L96
  mov    %ebp,%eax
  movb   $0x67,(%r14,%rax,1)
  add    $0x4,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L96:
  mov    $0x3,%edx
  lea    D98(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L409
  mov    %ebp,%eax
  movb   $0x68,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L409:
  mov    $0x2,%edx
  lea    D227(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L323
  mov    %ebp,%eax
  movb   $0x7a,(%r14,%rax,1)
  add    $0x2,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L323:
  mov    $0x3,%edx
  lea    D54(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L326
  mov    %ebp,%eax
  movb   $0x6b,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L326:
  mov    $0x2,%edx
  lea    D111(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L452
  mov    %ebp,%eax
  movb   $0x6c,(%r14,%rax,1)
  add    $0x2,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L452:
  mov    $0x2,%edx
  lea    D189(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L773
  mov    %ebp,%eax
  movb   $0x6d,(%r14,%rax,1)
  add    $0x2,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L773:
  mov    $0x2,%edx
  lea    D269(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L566
  mov    %ebp,%eax
  movb   $0x6e,(%r14,%rax,1)
  add    $0x2,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L566:
  mov    $0x3,%edx
  lea    D183(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L619
  mov    %ebp,%eax
  movb   $0x6f,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L619:
  mov    $0x3,%edx
  lea    D242(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L398
  mov    %ebp,%eax
  movb   $0x70,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L398:
  mov    $0x3,%edx
  lea    D206(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L573
  mov    %ebp,%eax
  movb   $0x71,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L573:
  mov    $0x3,%edx
  lea    D245(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L16
  mov    %ebp,%eax
  movb   $0x72,(%r14,%rax,1)
  add    $0x3,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L16:
  mov    $0x6,%edx
  lea    D172(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L853
  mov    %ebp,%eax
  movb   $0x77,(%r14,%rax,1)
  add    $0x6,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L853:
  mov    $0x9,%edx
  lea    D265(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L845
  mov    %ebp,%eax
  movb   $0x74,(%r14,%rax,1)
  add    $0x9,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L845:
  mov    $0x5,%edx
  lea    D36(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L617
  mov    %ebp,%eax
  movb   $0x75,(%r14,%rax,1)
  add    $0x5,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L617:
  mov    $0x4,%edx
  lea    D253(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L635
  mov    %ebp,%eax
  movb   $0x76,(%r14,%rax,1)
  add    $0x4,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L635:
  mov    $0x5,%edx
  lea    D279(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L772
  mov    %ebp,%eax
  movb   $0x73,(%r14,%rax,1)
  add    $0x5,%r12d
  lea    0x1(%rbp),%ebp
  jmp    L609
L772:
  mov    $0x2,%edx
  lea    D284(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L108
  mov    %ebp,%eax
  movb   $0x55,(%r14,%rax,1)
  add    $0x1,%ebp
  add    $0x2,%r12d
  jmp    L609
L108:
  cmp    $0x65,%r13b
  je     L499
  mov    $0x2,%edx
  lea    D90(%rip),%rsi
  mov    %rbx,%rdi
  call   <strncmp@plt>
  test   %eax,%eax
  jne    L260
  mov    %ebp,%eax
  movb   $0x57,(%r14,%rax,1)
  add    $0x1,%ebp
  add    $0x2,%r12d
  jmp    L609
L499:
  mov    %ebp,%eax
  movb   $0x56,(%r14,%rax,1)
  add    $0x1,%ebp
  add    $0x1,%r12d
  jmp    L609
L260:
  cmp    $0x2d,%r13b
  jne    L276
  test   %r12d,%r12d
  je     L815
L276:
  cmp    $0x28,%r13b
  je     L315
  cmp    $0x29,%r13b
  je     L186
L321:
  movsbl %r13b,%ebx
  mov    %ebx,%edi
  call   <isalpha@plt>
  mov    %eax,0x18(%rsp)
  test   %eax,%eax
  jne    L204
L429:
  movsbl %r13b,%eax
  sub    $0x30,%eax
  cmp    $0x9,%eax
  jbe    L416
L470:
  cmpl   $0x0,0x18(%rsp)
  je     L771
L493:
  add    $0x1,%r12d
  mov    %r12d,%eax
  mov    0x8(%rsp),%rcx
  movsbl (%rcx,%rax,1),%eax
  sub    $0x30,%eax
  cmp    $0x9,%eax
  ja     L218
  lea    0x1(%rbp),%eax
  mov    %ebp,%edx
  mov    %r13b,(%r14,%rdx,1)
  add    $0x2,%ebp
  mov    %eax,%eax
  movb   $0x2a,(%r14,%rax,1)
  jmp    L609
L815:
  lea    0x1(%rbp),%eax
  mov    %ebp,%edx
  movb   $0x30,(%r14,%rdx,1)
  add    $0x2,%ebp
  movzbl (%rbx),%edx
  mov    %eax,%eax
  mov    %dl,(%r14,%rax,1)
  mov    $0x1,%r12d
  jmp    L609
L315:
  lea    0x1(%r12),%eax
  add    0x8(%rsp),%rax
  cmpb   $0x2d,(%rax)
  jne    L321
  mov    %ebp,%edx
  movb   $0x28,(%r14,%rdx,1)
  lea    0x2(%rbp),%edx
  lea    0x1(%rbp),%ecx
  movb   $0x30,(%r14,%rcx,1)
  add    $0x2,%r12d
  add    $0x3,%ebp
  movzbl (%rax),%ecx
  mov    %edx,%eax
  mov    %cl,(%r14,%rax,1)
  jmp    L609
L186:
  lea    0x1(%r12),%edx
  mov    %edx,%eax
  mov    0x8(%rsp),%rcx
  cmpb   $0x28,(%rcx,%rax,1)
  jne    L145
  lea    0x1(%rbp),%eax
  mov    %ebp,%ecx
  movb   $0x29,(%r14,%rcx,1)
  add    $0x2,%ebp
  mov    %eax,%eax
  movb   $0x2a,(%r14,%rax,1)
  mov    %edx,%r12d
  jmp    L609
L204:
  lea    0x1(%r12),%eax
  mov    %eax,0x14(%rsp)
  mov    %eax,%eax
  mov    0x8(%rsp),%rcx
  movzbl (%rcx,%rax,1),%ecx
  mov    %cl,0x1f(%rsp)
  movsbl %cl,%edi
  call   <isalpha@plt>
  test   %eax,%eax
  je     L623
  mov    %ebx,%edi
  call   <toupper@plt>
  mov    %eax,%ecx
  lea    0x1(%rbp),%eax
  mov    %ebp,%edx
  mov    %cl,(%r14,%rdx,1)
  add    $0x2,%ebp
  mov    %eax,%eax
  movb   $0x2a,(%r14,%rax,1)
  mov    0x14(%rsp),%r12d
  jmp    L609
L623:
  cmpb   $0x28,0x1f(%rsp)
  jne    L200
  mov    %ebx,%edi
  call   <toupper@plt>
  mov    %eax,%ecx
  lea    0x1(%rbp),%eax
  mov    %ebp,%edx
  mov    %cl,(%r14,%rdx,1)
  add    $0x2,%ebp
  mov    %eax,%eax
  movb   $0x2a,(%r14,%rax,1)
  mov    0x14(%rsp),%r12d
  jmp    L609
L416:
  lea    0x1(%r12),%eax
  mov    %eax,0x14(%rsp)
  mov    %eax,%eax
  mov    0x8(%rsp),%rcx
  movzbl (%rcx,%rax,1),%eax
  cmp    $0x28,%al
  jne    L373
  lea    0x1(%rbp),%eax
  mov    %ebp,%edx
  mov    %r13b,(%r14,%rdx,1)
  add    $0x2,%ebp
  mov    %eax,%eax
  movb   $0x2a,(%r14,%rax,1)
  mov    0x14(%rsp),%r12d
  jmp    L609
L373:
  movsbl %al,%edi
  call   <isalpha@plt>
  test   %eax,%eax
  je     L470
  lea    0x1(%rbp),%eax
  mov    %ebp,%edx
  mov    %r13b,(%r14,%rdx,1)
  add    $0x2,%ebp
  mov    %eax,%eax
  movb   $0x2a,(%r14,%rax,1)
  mov    0x14(%rsp),%r12d
  jmp    L609
L218:
  mov    %ebx,%edi
  call   <toupper@plt>
  mov    %eax,%edx
  mov    %ebp,%eax
  mov    %dl,(%r14,%rax,1)
  lea    0x1(%rbp),%ebp
  jmp    L609
L771:
  add    $0x1,%r12d
  mov    %ebp,%eax
  mov    %r13b,(%r14,%rax,1)
  lea    0x1(%rbp),%ebp
  jmp    L609
L914:
  mov    $0x0,%ebp
L611:
  mov    %ebp,%ebp
  movb   $0x0,(%r14,%rbp,1)
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L200:
  cmp    $0x29,%r13b
  jne    L429
  jmp    L493
L145:
  movsbl %r13b,%ebx
  mov    %ebx,%edi
  call   <isalpha@plt>
  mov    %eax,0x18(%rsp)
  test   %eax,%eax
  jne    L204
  lea    0x1(%r12),%eax
  mov    %eax,0x14(%rsp)
  mov    %eax,%eax
  mov    0x8(%rsp),%rcx
  movsbl (%rcx,%rax,1),%edi
  call   <isalpha@plt>
  test   %eax,%eax
  je     L470
  lea    0x1(%rbp),%eax
  mov    %ebp,%edx
  movb   $0x29,(%r14,%rdx,1)
  add    $0x2,%ebp
  mov    %eax,%eax
  movb   $0x2a,(%r14,%rax,1)
  mov    0x14(%rsp),%r12d
  jmp    L609
```

tool_calls: name: retrieve_data
arguments: data_label: D287
data_type: string
name: retrieve_data
arguments: data_label: D30
data_type: string
name: retrieve_data
arguments: data_label: D119
data_type: string
name: retrieve_data
arguments: data_label: D140
data_type: string
name: retrieve_data
arguments: data_label: D175
data_type: string
name: retrieve_data
arguments: data_label: D83
data_type: string
name: retrieve_data
arguments: data_label: D148
data_type: string
name: retrieve_data
arguments: data_label: D254
data_type: string
name: retrieve_data
arguments: data_label: D70
data_type: string
name: retrieve_data
arguments: data_label: D130
data_type: string
name: retrieve_data
arguments: data_label: D69
data_type: string
name: retrieve_data
arguments: data_label: D193
data_type: string
name: retrieve_data
arguments: data_label: D98
data_type: string
name: retrieve_data
arguments: data_label: D227
data_type: string
name: retrieve_data
arguments: data_label: D54
data_type: string
name: retrieve_data
arguments: data_label: D111
data_type: string
name: retrieve_data
arguments: data_label: D189
data_type: string
name: retrieve_data
arguments: data_label: D269
data_type: string
name: retrieve_data
arguments: data_label: D183
data_type: string
name: retrieve_data
arguments: data_label: D242
data_type: string
name: retrieve_data
arguments: data_label: D206
data_type: string
name: retrieve_data
arguments: data_label: D245
data_type: string
name: retrieve_data
arguments: data_label: D172
data_type: string
name: retrieve_data
arguments: data_label: D265
data_type: string
name: retrieve_data
arguments: data_label: D36
data_type: string
name: retrieve_data
arguments: data_label: D253
data_type: string
name: retrieve_data
arguments: data_label: D279
data_type: string
name: retrieve_data
arguments: data_label: D284
data_type: string
name: retrieve_data
arguments: data_label: D90
data_type: string

tool: D287: resComp

tool: D30: res

tool: D119: ans

tool: D140: sqrt

tool: D175: sin

tool: D83: sen

tool: D148: cos

tool: D254: tan

tool: D70: asin

tool: D130: asen

tool: D69: acos

tool: D193: atan

tool: D98: exp

tool: D227: ln

tool: D54: log

tool: D111: sh

tool: D189: ch

tool: D269: th

tool: D183: ash

tool: D242: ach

tool: D206: ath

tool: D245: pow

tool: D172: gamma'

tool: D265: factorial

tool: D36: betha

tool: D253: prim

tool: D279: gamma

tool: D284: pi

tool: D90: r2

assistant: ```c
void pretraducir(char *origS, char *newS) {
  unsigned int i = 0, j = 0;
  while (origS[i] != '\0') {
    if (origS[i] == 'i') {
      if (!esOperador(origS[i + 1]) && origS[i + 1] != '\0' && origS[i + 1] != ')' && origS[i + 1] != '!') {
        newS[j++] = origS[i++];
        newS[j++] = '*';
      } else
        newS[j++] = origS[i++];
    } else if (strncmp(&origS[i], "resComp", strlen("resComp")) == 0) {
      strncpy(&newS[j], "resComp", strlen("resComp"));
      j += strlen("resComp");
      i += strlen("resComp");
    } else if (strncmp(&origS[i], "res", strlen("res")) == 0 || strncmp(&origS[i], "ans", strlen("ans")) == 0) {
      strncpy(&newS[j], "res", strlen("res"));
      j += strlen("res");
      i += strlen("res");
    } else if (strncmp(&origS[i], "sqrt", strlen("sqrt")) == 0) {
      newS[j++] = 'a';
      i += strlen("sqrt");
    } else if (strncmp(&origS[i], "sin", strlen("sin")) == 0 || strncmp(&origS[i], "sen", strlen("sen")) == 0) {
      newS[j++] = 'b';
      i += strlen("sin");
    } else if (strncmp(&origS[i], "cos", strlen("cos")) == 0) {
      newS[j++] = 'c';
      i += strlen("cos");
    } else if (strncmp(&origS[i], "tan", strlen("tan")) == 0) {
      newS[j++] = 'd';
      i += strlen("tan");
    } else if (strncmp(&origS[i], "asin", strlen("asin")) == 0 || strncmp(&origS[i], "asen", strlen("asen")) == 0) {
      newS[j++] = 'e';
      i += strlen("asin");
    } else if (strncmp(&origS[i], "acos", strlen("acos")) == 0) {
      newS[j++] = 'f';
      i += strlen("acos");
    } else if (strncmp(&origS[i], "atan", strlen("atan")) == 0) {
      newS[j++] = 'g';
      i += strlen("atan");
    } else if (strncmp(&origS[i], "exp", strlen("exp")) == 0) {
      newS[j++] = 'h';
      i += strlen("exp");
    } else if (strncmp(&origS[i], "ln", strlen("ln")) == 0) {
      newS[j++] = 'z';
      i += strlen("ln");
    } else if (strncmp(&origS[i], "log", strlen("log")) == 0) {
      newS[j++] = 'k';
      i += strlen("log");
    } else if (strncmp(&origS[i], "sh", strlen("sh")) == 0) {
      newS[j++] = 'l';
      i += strlen("sh");
    } else if (strncmp(&origS[i], "ch", strlen("ch")) == 0) {
      newS[j++] = 'm';
      i += strlen("ch");
    } else if (strncmp(&origS[i], "th", strlen("th")) == 0) {
      newS[j++] = 'n';
      i += strlen("th");
    } else if (strncmp(&origS[i], "ash", strlen("ash")) == 0) {
      newS[j++] = 'o';
      i += strlen("ash");
    } else if (strncmp(&origS[i], "ach", strlen("ach")) == 0) {
      newS[j++] = 'p';
      i += strlen("ach");
    } else if (strncmp(&origS[i], "ath", strlen("ath")) == 0) {
      newS[j++] = 'q';
      i += strlen("ath");
    } else if (strncmp(&origS[i], "pow", strlen("pow")) == 0) {
      newS[j++] = 'r';
      i += strlen("pow");
    } else if (strncmp(&origS[i], "gamma'", strlen("gamma'")) == 0) {
      newS[j++] = 'w';
      i += strlen("gamma'");
    } else if (strncmp(&origS[i], "factorial", strlen("factorial")) == 0) {
      newS[j++] = 't';
      i += strlen("factorial");
    } else if (strncmp(&origS[i], "betha", strlen("betha")) == 0) {
      newS[j++] = 'u';
      i += strlen("betha");
    } else if (strncmp(&origS[i], "prim", strlen("prim")) == 0) {
      newS[j++] = 'v';
      i += strlen("prim");
    } else if (strncmp(&origS[i], "gamma", strlen("gamma")) == 0) {
      newS[j++] = 's';
      i += strlen("gamma");
    } else if (strncmp(&origS[i], "pi", strlen("pi")) == 0) {
      newS[j] = 'U';
      j++;
      i += strlen("pi");
    } else if (strncmp(&origS[i], "e", strlen("e")) == 0) {
      newS[j] = 'V';
      j++;
      i += strlen("e");
    } else if (strncmp(&origS[i], "r2", strlen("r2")) == 0) {
      newS[j] = 'W';
      j++;
      i += strlen("r2");
    } else if (i == 0 && origS[i] == '-') {
      newS[j++] = '0';
      newS[j++] = origS[i++];
    } else if (origS[i] == '(' && origS[i + 1] == '-') {
      newS[j++] = origS[i++];
      newS[j++] = '0';
      newS[j++] = origS[i++];
    } else if ((origS[i] == ')') && (origS[i + 1] == '(')) {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isalpha(origS[i]) && isalpha(origS[i + 1])) {
      newS[j++] = toupper(origS[i++]);
      newS[j++] = '*';
    } else if (isalpha(origS[i]) && origS[i + 1] == '(') {
      newS[j++] = toupper(origS[i++]);
      newS[j++] = '*';
    } else if (origS[i] == ')' && isalpha(origS[i + 1])) {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isdigit(origS[i]) && origS[i + 1] == '(') {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isdigit(origS[i]) && isalpha(origS[i + 1])) {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isalpha(origS[i]) && isdigit(origS[i + 1])) {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isalpha(origS[i])) {
      newS[j++] = toupper(origS[i++]);
    } else
      newS[j++] = origS[i++];
  }
  newS[j] = '\0';
  return;
}
```