#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*/ CreateADigitSmaller(int *, int);
int SolutionSameDigitsAsNumber(int *, int, int *);
bool SolutionDifferentDigitsThanNumber(int *Number, int *CopyOfNumber,
                                       int NumberOfDigits, int *Solution) {
  bool Valid = false;
  if (Number[0] * 10 + Number[1] == Number[NumberOfDigits - 1] + 10) {
    CreateADigitSmaller(Number, NumberOfDigits);
    CreateADigitSmaller(CopyOfNumber, NumberOfDigits);
    Valid =
        SolutionSameDigitsAsNumber(CopyOfNumber, NumberOfDigits - 1, Solution);
    return Valid;
  } else if (Number[0] * 10 + Number[1] - 1 ==
             Number[NumberOfDigits - 1] + 10) {
    CreateADigitSmaller(Number, NumberOfDigits);
    CreateADigitSmaller(CopyOfNumber, NumberOfDigits);
    Valid =
        SolutionSameDigitsAsNumber(CopyOfNumber, NumberOfDigits - 1, Solution);
    return Valid;
  } else if (Number[0] * 10 + Number[1] - 1 == Number[NumberOfDigits - 1]) {
    CreateADigitSmaller(Number, NumberOfDigits);
    CreateADigitSmaller(CopyOfNumber, NumberOfDigits);
    Valid =
        SolutionSameDigitsAsNumber(CopyOfNumber, NumberOfDigits - 1, Solution);
    return Valid;
  } else
    return false;
}


x86 assembly (clang, -O0):
<SolutionDifferentDigitsThanNumber>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
imul   $0xa,(%rax),%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0xa,%ecx
cmp    %ecx,%eax
jne    11a0 <SolutionDifferentDigitsThanNumber+0x80>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1030 <CreateADigitSmaller@plt>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1030 <CreateADigitSmaller@plt>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
sub    $0x1,%esi
mov    -0x28(%rbp),%rdx
call   1040 <SolutionSameDigitsAsNumber@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    126c <SolutionDifferentDigitsThanNumber+0x14c>
mov    -0x10(%rbp),%rax
imul   $0xa,(%rax),%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
sub    $0x1,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0xa,%ecx
cmp    %ecx,%eax
jne    1205 <SolutionDifferentDigitsThanNumber+0xe5>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1030 <CreateADigitSmaller@plt>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1030 <CreateADigitSmaller@plt>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
sub    $0x1,%esi
mov    -0x28(%rbp),%rdx
call   1040 <SolutionSameDigitsAsNumber@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    126c <SolutionDifferentDigitsThanNumber+0x14c>
mov    -0x10(%rbp),%rax
imul   $0xa,(%rax),%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
sub    $0x1,%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1265 <SolutionDifferentDigitsThanNumber+0x145>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1030 <CreateADigitSmaller@plt>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1030 <CreateADigitSmaller@plt>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
sub    $0x1,%esi
mov    -0x28(%rbp),%rdx
call   1040 <SolutionSameDigitsAsNumber@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    126c <SolutionDifferentDigitsThanNumber+0x14c>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SolutionDifferentDigitsThanNumber>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rcx,%r14
mov    %edx,%ebx
mov    %rsi,%r15
mov    (%rdi),%eax
lea    (%rax,%rax,4),%eax
add    %eax,%eax
add    0x4(%rdi),%eax
movslq %edx,%rcx
mov    -0x4(%rdi,%rcx,4),%ecx
lea    0xa(%rcx),%edx
cmp    %edx,%eax
je     115f <SolutionDifferentDigitsThanNumber+0x3f>
add    $0xffffffff,%eax
cmp    %edx,%eax
je     115f <SolutionDifferentDigitsThanNumber+0x3f>
cmp    %ecx,%eax
je     115f <SolutionDifferentDigitsThanNumber+0x3f>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%rbx),%ebp
mov    %ebx,%esi
call   1030 <CreateADigitSmaller@plt>
mov    %r15,%rdi
mov    %ebx,%esi
call   1030 <CreateADigitSmaller@plt>
mov    %r15,%rdi
mov    %ebp,%esi
mov    %r14,%rdx
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <SolutionSameDigitsAsNumber@plt>

LLVM IR (-O0):
define i32 @SolutionDifferentDigitsThanNumber(i32* %0, i32* %1, i32 %2, i32* %3) {
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32
store i32* %0, i32** %6
store i32* %1, i32** %7
store i32 %2, i32* %8
store i32* %3, i32** %9
store i32 0, i32* %10
%11 = load i32*, i32** %6
%12 = getelementptr inbounds i32, i32* %11, i64 0
%13 = load i32, i32* %12
%14 = mul nsw i32 %13, 10
%15 = load i32*, i32** %6
%16 = getelementptr inbounds i32, i32* %15, i64 1
%17 = load i32, i32* %16
%18 = add nsw i32 %14, %17
%19 = load i32*, i32** %6
%20 = load i32, i32* %8
%21 = sub nsw i32 %20, 1
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %19, i64 %22
%24 = load i32, i32* %23
%25 = add nsw i32 %24, 10
%26 = icmp eq i32 %18, %25
br i1 %26, label %27, label %40
27: ; preds = %4
%28 = load i32*, i32** %6
%29 = load i32, i32* %8
%30 = call i32 @CreateADigitSmaller(i32* %28, i32 %29)
%31 = load i32*, i32** %7
%32 = load i32, i32* %8
%33 = call i32 @CreateADigitSmaller(i32* %31, i32 %32)
%34 = load i32*, i32** %7
%35 = load i32, i32* %8
%36 = sub nsw i32 %35, 1
%37 = load i32*, i32** %9
%38 = call i32 @SolutionSameDigitsAsNumber(i32* %34, i32 %36, i32* %37)
store i32 %38, i32* %10
%39 = load i32, i32* %10
store i32 %39, i32* %5
br label %102
40: ; preds = %4
%41 = load i32*, i32** %6
%42 = getelementptr inbounds i32, i32* %41, i64 0
%43 = load i32, i32* %42
%44 = mul nsw i32 %43, 10
%45 = load i32*, i32** %6
%46 = getelementptr inbounds i32, i32* %45, i64 1
%47 = load i32, i32* %46
%48 = add nsw i32 %44, %47
%49 = sub nsw i32 %48, 1
%50 = load i32*, i32** %6
%51 = load i32, i32* %8
%52 = sub nsw i32 %51, 1
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32, i32* %50, i64 %53
%55 = load i32, i32* %54
%56 = add nsw i32 %55, 10
%57 = icmp eq i32 %49, %56
br i1 %57, label %58, label %71
58: ; preds = %40
%59 = load i32*, i32** %6
%60 = load i32, i32* %8
%61 = call i32 @CreateADigitSmaller(i32* %59, i32 %60)
%62 = load i32*, i32** %7
%63 = load i32, i32* %8
%64 = call i32 @CreateADigitSmaller(i32* %62, i32 %63)
%65 = load i32*, i32** %7
%66 = load i32, i32* %8
%67 = sub nsw i32 %66, 1
%68 = load i32*, i32** %9
%69 = call i32 @SolutionSameDigitsAsNumber(i32* %65, i32 %67, i32* %68)
store i32 %69, i32* %10
%70 = load i32, i32* %10
store i32 %70, i32* %5
br label %102
71: ; preds = %40
%72 = load i32*, i32** %6
%73 = getelementptr inbounds i32, i32* %72, i64 0
%74 = load i32, i32* %73
%75 = mul nsw i32 %74, 10
%76 = load i32*, i32** %6
%77 = getelementptr inbounds i32, i32* %76, i64 1
%78 = load i32, i32* %77
%79 = add nsw i32 %75, %78
%80 = sub nsw i32 %79, 1
%81 = load i32*, i32** %6
%82 = load i32, i32* %8
%83 = sub nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %81, i64 %84
%86 = load i32, i32* %85
%87 = icmp eq i32 %80, %86
br i1 %87, label %88, label %101
88: ; preds = %71
%89 = load i32*, i32** %6
%90 = load i32, i32* %8
%91 = call i32 @CreateADigitSmaller(i32* %89, i32 %90)
%92 = load i32*, i32** %7
%93 = load i32, i32* %8
%94 = call i32 @CreateADigitSmaller(i32* %92, i32 %93)
%95 = load i32*, i32** %7
%96 = load i32, i32* %8
%97 = sub nsw i32 %96, 1
%98 = load i32*, i32** %9
%99 = call i32 @SolutionSameDigitsAsNumber(i32* %95, i32 %97, i32* %98)
store i32 %99, i32* %10
%100 = load i32, i32* %10
store i32 %100, i32* %5
br label %102
101: ; preds = %71
store i32 0, i32* %5
br label %102
102: ; preds = %101, %88, %58, %27
%103 = load i32, i32* %5
ret i32 %103
}

LLVM IR (-O2):
define i32 @SolutionDifferentDigitsThanNumber(i32* %0, i32* %1, i32 %2, i32* %3) {
%5 = load i32, i32* %0
%6 = mul nsw i32 %5, 10
%7 = getelementptr inbounds i32, i32* %0, i64 1
%8 = load i32, i32* %7
%9 = add nsw i32 %6, %8
%10 = add nsw i32 %2, -1
%11 = sext i32 %10 to i64
%12 = getelementptr inbounds i32, i32* %0, i64 %11
%13 = load i32, i32* %12
%14 = add nsw i32 %13, 10
%15 = icmp eq i32 %9, %14
br i1 %15, label %21, label %16
16: ; preds = %4
%17 = add nsw i32 %9, -1
%18 = icmp eq i32 %17, %14
%19 = icmp eq i32 %17, %13
%20 = or i1 %18, %19
br i1 %20, label %21, label %25
21: ; preds = %16, %4
%22 = tail call i32 @CreateADigitSmaller(i32* %0, i32 %2)
%23 = tail call i32 @CreateADigitSmaller(i32* %1, i32 %2)
%24 = tail call i32 @SolutionSameDigitsAsNumber(i32* %1, i32 %10, i32* %3)
br label %25
25: ; preds = %16, %21
%26 = phi i32 [ %24, %21 ], [ 0, %16 ]
ret i32 %26
}