#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 */
typedef int /*<<< orphan*/ pcNewRight;
typedef int /*<<< orphan*/ pcNewLeft;
typedef char iDigitDiff;

/* Variables and functions */
int /*<<< orphan*/ Equalize(char *, char *, char **, char **);
int /*<<< orphan*/ free(char *);
char *my_strdup(char *);
int strlen(char *);
char *a_minus(char *pcL, char *pcR) {
  char *pcResult;
  char *pcNewLeft, *pcNewRight;
  int iDigitDiff;
  int i, iCarry;
  Equalize(pcL, pcR, &pcNewLeft, &pcNewRight);
  pcResult = my_strdup(pcNewLeft);
  i = strlen(pcNewLeft);
  i--;
  iCarry = 0;
  while ((i != 0) && (pcL[i] != 'x')) {
    iDigitDiff = (((pcNewLeft[i]) > '9') ? ((pcNewLeft[i]) - 'A' + 10)
                                         : ((pcNewLeft[i]) - '0')) -
                 (((pcNewRight[i]) > '9') ? ((pcNewRight[i]) - 'A' + 10)
                                          : ((pcNewRight[i]) - '0'));
    iDigitDiff = iDigitDiff + iCarry;
    iDigitDiff += 0x10;
    iCarry = iDigitDiff / 0x10;
    iCarry--;
    iDigitDiff = iDigitDiff % 0x10;
    pcResult[i] =
        (((iDigitDiff) > 9) ? ((iDigitDiff)-10 + 'A') : ((iDigitDiff) + '0'));
    i--;
  }
  free(pcNewLeft);
  free(pcNewRight);
  return pcResult;
}


x86 assembly (clang, -O0):
<a_minus>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    -0x20(%rbp),%rdx
lea    -0x28(%rbp),%rcx
call   1050 <Equalize@plt>
mov    -0x20(%rbp),%rdi
call   1060 <my_strdup@plt>
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x30(%rbp)
mov    %al,-0x35(%rbp)
je     11b2 <a_minus+0x72>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x78,%eax
setne  %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    11c2 <a_minus+0x82>
jmp    12ce <a_minus+0x18e>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jle    11f1 <a_minus+0xb1>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x41,%eax
add    $0xa,%eax
mov    %eax,-0x3c(%rbp)
jmp    1203 <a_minus+0xc3>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jle    1238 <a_minus+0xf8>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x41,%eax
add    $0xa,%eax
mov    %eax,-0x44(%rbp)
jmp    124a <a_minus+0x10a>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,-0x2c(%rbp)
cmpl   $0x9,-0x2c(%rbp)
jle    12a7 <a_minus+0x167>
mov    -0x2c(%rbp),%eax
sub    $0xa,%eax
add    $0x41,%eax
mov    %eax,-0x48(%rbp)
jmp    12b0 <a_minus+0x170>
mov    -0x2c(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    118e <a_minus+0x4e>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<a_minus>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %rdi,%r14
mov    %rsp,%rdx
lea    0x8(%rsp),%rcx
call   1050 <Equalize@plt>
mov    (%rsp),%rdi
call   1060 <my_strdup@plt>
mov    %rax,%r15
mov    (%rsp),%rdi
call   1040 <strlen@plt>
add    $0xffffffff,%eax
je     11e7 <a_minus+0xa7>
cltq
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
cmpb   $0x78,(%r14,%rax,1)
je     11e7 <a_minus+0xa7>
mov    (%rsp),%rdx
movsbl (%rdx,%rax,1),%edx
cmp    $0x3a,%edx
mov    0x8(%rsp),%rsi
movsbl (%rsi,%rax,1),%esi
lea    -0x37(%rcx,%rdx,1),%edi
lea    -0x30(%rcx,%rdx,1),%edx
cmovge %edi,%edx
sub    %esi,%edx
lea    0x30(%rdx),%ecx
add    $0x37,%edx
cmp    $0x3a,%esi
cmovl  %ecx,%edx
lea    0x10(%rdx),%esi
lea    0x1f(%rdx),%edi
test   %esi,%esi
cmovns %esi,%edi
mov    %edi,%ecx
sar    $0x4,%ecx
add    $0xffffffff,%ecx
and    $0xfffffff0,%edi
sub    %edi,%esi
lea    0x37(%rsi),%ebx
neg    %edi
cmp    $0xa,%esi
lea    0x40(%rdx,%rdi,1),%edx
cmovge %ebx,%edx
mov    %dl,(%r15,%rax,1)
add    $0xffffffffffffffff,%rax
test   %eax,%eax
jne    1180 <a_minus+0x40>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i8* @a_minus(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
%11 = load i8*, i8** %3
%12 = load i8*, i8** %4
%13 = call i32 @Equalize(i8* %11, i8* %12, i8** %6, i8** %7)
%14 = load i8*, i8** %6
%15 = call i8* @my_strdup(i8* %14)
store i8* %15, i8** %5
%16 = load i8*, i8** %6
%17 = call i32 @strlen(i8* %16)
store i32 %17, i32* %9
%18 = load i32, i32* %9
%19 = add nsw i32 %18, -1
store i32 %19, i32* %9
store i32 0, i32* %10
br label %20
20: ; preds = %107, %2
%21 = load i32, i32* %9
%22 = icmp ne i32 %21, 0
br i1 %22, label %23, label %31
23: ; preds = %20
%24 = load i8*, i8** %3
%25 = load i32, i32* %9
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8, i8* %24, i64 %26
%28 = load i8, i8* %27
%29 = sext i8 %28 to i32
%30 = icmp ne i32 %29, 120
br label %31
31: ; preds = %23, %20
%32 = phi i1 [ false, %20 ], [ %30, %23 ]
br i1 %32, label %33, label %116
33: ; preds = %31
%34 = load i8*, i8** %6
%35 = load i32, i32* %9
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i8, i8* %34, i64 %36
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = icmp sgt i32 %39, 57
br i1 %40, label %41, label %50
41: ; preds = %33
%42 = load i8*, i8** %6
%43 = load i32, i32* %9
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = sub nsw i32 %47, 65
%49 = add nsw i32 %48, 10
br label %58
50: ; preds = %33
%51 = load i8*, i8** %6
%52 = load i32, i32* %9
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %51, i64 %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = sub nsw i32 %56, 48
br label %58
58: ; preds = %50, %41
%59 = phi i32 [ %49, %41 ], [ %57, %50 ]
%60 = load i8*, i8** %7
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %60, i64 %62
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = icmp sgt i32 %65, 57
br i1 %66, label %67, label %76
67: ; preds = %58
%68 = load i8*, i8** %7
%69 = load i32, i32* %9
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
%72 = load i8, i8* %71
%73 = sext i8 %72 to i32
%74 = sub nsw i32 %73, 65
%75 = add nsw i32 %74, 10
br label %84
76: ; preds = %58
%77 = load i8*, i8** %7
%78 = load i32, i32* %9
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i8, i8* %77, i64 %79
%81 = load i8, i8* %80
%82 = sext i8 %81 to i32
%83 = sub nsw i32 %82, 48
br label %84
84: ; preds = %76, %67
%85 = phi i32 [ %75, %67 ], [ %83, %76 ]
%86 = sub nsw i32 %59, %85
store i32 %86, i32* %8
%87 = load i32, i32* %8
%88 = load i32, i32* %10
%89 = add nsw i32 %87, %88
store i32 %89, i32* %8
%90 = load i32, i32* %8
%91 = add nsw i32 %90, 16
store i32 %91, i32* %8
%92 = load i32, i32* %8
%93 = sdiv i32 %92, 16
store i32 %93, i32* %10
%94 = load i32, i32* %10
%95 = add nsw i32 %94, -1
store i32 %95, i32* %10
%96 = load i32, i32* %8
%97 = srem i32 %96, 16
store i32 %97, i32* %8
%98 = load i32, i32* %8
%99 = icmp sgt i32 %98, 9
br i1 %99, label %100, label %104
100: ; preds = %84
%101 = load i32, i32* %8
%102 = sub nsw i32 %101, 10
%103 = add nsw i32 %102, 65
br label %107
104: ; preds = %84
%105 = load i32, i32* %8
%106 = add nsw i32 %105, 48
br label %107
107: ; preds = %104, %100
%108 = phi i32 [ %103, %100 ], [ %106, %104 ]
%109 = trunc i32 %108 to i8
%110 = load i8*, i8** %5
%111 = load i32, i32* %9
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8, i8* %110, i64 %112
store i8 %109, i8* %113
%114 = load i32, i32* %9
%115 = add nsw i32 %114, -1
store i32 %115, i32* %9
br label %20
116: ; preds = %31
%117 = load i8*, i8** %6
%118 = call i32 @free(i8* %117)
%119 = load i8*, i8** %7
%120 = call i32 @free(i8* %119)
%121 = load i8*, i8** %5
ret i8* %121
}

LLVM IR (-O2):
define i8* @a_minus(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = bitcast i8** %3 to i8*
%6 = bitcast i8** %4 to i8*
%7 = call i32 @Equalize(i8* %0, i8* %1, i8** %3, i8** %4)
%8 = load i8*, i8** %3
%9 = call i8* @my_strdup(i8* %8)
%10 = load i8*, i8** %3
%11 = call i32 @strlen(i8* %10)
%12 = add i32 %11, -1
%13 = icmp eq i32 %12, 0
br i1 %13, label %51, label %14
14: ; preds = %2
%15 = sext i32 %12 to i64
br label %16
16: ; preds = %14, %22
%17 = phi i64 [ %15, %14 ], [ %48, %22 ]
%18 = phi i32 [ 0, %14 ], [ %41, %22 ]
%19 = getelementptr inbounds i8, i8* %0, i64 %17
%20 = load i8, i8* %19
%21 = icmp eq i8 %20, 120
br i1 %21, label %51, label %22
22: ; preds = %16
%23 = load i8*, i8** %3
%24 = getelementptr inbounds i8, i8* %23, i64 %17
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = icmp sgt i8 %25, 57
%28 = select i1 %27, i32 -55, i32 -48
%29 = load i8*, i8** %4
%30 = getelementptr inbounds i8, i8* %29, i64 %17
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = icmp sgt i8 %31, 57
%34 = select i1 %33, i32 55, i32 48
%35 = add nsw i32 %18, 16
%36 = add nsw i32 %35, %26
%37 = add nsw i32 %36, %28
%38 = sub i32 %37, %32
%39 = add i32 %38, %34
%40 = sdiv i32 %39, 16
%41 = add nsw i32 %40, -1
%42 = srem i32 %39, 16
%43 = icmp sgt i32 %42, 9
%44 = select i1 %43, i32 55, i32 48
%45 = add nsw i32 %44, %42
%46 = trunc i32 %45 to i8
%47 = getelementptr inbounds i8, i8* %9, i64 %17
store i8 %46, i8* %47
%48 = add nsw i64 %17, -1
%49 = trunc i64 %48 to i32
%50 = icmp eq i32 %49, 0
br i1 %50, label %51, label %16
51: ; preds = %16, %22, %2
%52 = load i8*, i8** %3
%53 = call i32 @free(i8* %52)
%54 = load i8*, i8** %4
%55 = call i32 @free(i8* %54)
ret i8* %9
}