[Question]
  [
Given a non-negative integer, return the absolute difference between the sum of its even digits and the sum of its odd digits.
## Default Rules
* Standard Loopholes apply.
* You can take input and provide output by any standard Input / Output method.
* You may take input as a String, as an Integer or as a list of digits.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes **in every language** wins!
## Test Cases
```
Input ~> Output
0 ~> 0 (|0-0| = 0)
1 ~> 1 (|1-0| = 1)
12 ~> 1 (|2-1| = 1)
333 ~> 9 (|0-(3+3+3)| = 9)
459 ~> 10 (|4-(5+9)| = 10)
2469 ~> 3 (|(2+4+6)-9| = 3)
1234 ~> 2 (|(2+4)-(1+3)| = 2)
```
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
-*√¶.¬πA
```
[Try it online!](https://tio.run/##y0rNyan8/19X6/AyvUM7Hf8f3eNyuF3lUdMa9///DXUUDHQUDI10FIyNjXUUTEwtdRSMTMwsQWLGJgA "Jelly ‚Äì Try It Online")
### How it works
```
-*√¶.¬πA  Main link. Argument: A (digit array)
-*      Raise -1 to A's digits, yielding 1 for even digits and -1 for odd ones.
    ¬π   Identity; yield A.
  √¶.    Take the dot product of the units and the digits.
     A  Apply absolute value.
```
[Answer]
# SHENZHEN I/O MCxxxx scripts, 197 (126+71) bytes
Chip 1 (MC6000):
* x0: Input as list
* x2: Chip 2 x1
* x3: MC4010
```
mov 0 dat
j:
mov x0 acc
mov 70 x3
mov -1 x3
mov acc x3
mul x3
mov acc x2
mov dat acc
add 1
tlt acc 3
mov acc dat
+jmp j
slx x0
```
Chip 2 (MC4000):
* p0: Output
* x0: MC4010
* x1: Chip 1 x2
```
mov x1 acc
add x1
add x1
mov 30 x0
mov 0 x0
mov acc x0
mov x0 p0
slx x1
```
[Answer]
## Python 2, 39 bytes
Takes integer as list. [Try it online](https://tio.run/##K6gsycjPM/rvYxvzPycxNyklUcHRKjGpWKO4NFdDQ9dQU0srUytTIS2/SCFTITNPwVFT8z@cE22gY6hjpGNopGNsbKxjYmqpY2RiZgnkG5vEWnEpAEFBUWZeiYKPRm5igQaQpZOQmQA0AAA)
```
lambda A:abs(sum((-1)**i*i for i in A))
```
-3 bytes thanks to @Mr.Xcoder  
-1 byte thanks to @ovs
[Answer]
# Mathematica, 20 bytes
```
Abs@Tr[(-1)^(g=#)g]&
```
takes as input a list of digits
special thanx to @LLlAMnYP for letting me know about the "new rules"
[Answer]
# TI-Basic, ~~18~~ 9 bytes
```
abs(sum((-1)^AnsAns
```
**Explanation**
Multiplies each digit in the list by -1 to its power, negating each odd digit, before summing them.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~59~~ ~~58~~ 57 bytes
```
i;f(char*v){for(i=0;*v;v++)i+=*v%2?*v-48:48-*v;v=abs(i);}
```
[Try it online!](https://tio.run/##dctBC8IgGMbx@z7FEAa@OmGpxUqkL9LFDOs9zMLCy9hnt1XXvD38fzxeXL0vBU2g/uYSyzCHe6JoB8OyyZwDcstyJ48sCz0e9Cg@3brzkyKYpUwOI/V9hu99tblp20fC@AqUdJdTJP06BgJg/sGmCrImSqka6e2@RlLvftYs5Q0 "C (gcc) ‚Äì Try It Online")
[Answer]
## R, 30 29 bytes
```
abs(sum((d=scan())-2*d*d%%2))
```
`d = scan()` takes the input number by one digit after the other.
-1 byte thanks to @Giuseppe!
[Answer]
# C#, 57 bytes
```
namespace System.Linq{i=>Math.Abs(i.Sum(n=>n%2<1?n:-n))}
```
Takes input as `i` and sums the integers by turning the odds to negative.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 bytes
```
x_*JpZ√Éa
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=eF8qSnBaw2E=&input=WzEsMiwzLDRd)
### Explanation
```
 x_  *JpZ√É a
UxZ{Z*JpZ} a
                Implicit: U = list of digits
UxZ{     }      Take the sum of each item Z in U mapped through the following function:
      JpZ         Return (-1) ** Z
    Z*            times Z. This gives Z if even, -Z if odd.
           a    Take the absolute value of the result.
                Implicit: output result of last expression
```
[Answer]
# [Neim](https://github.com/okx-code/Neim), 7 bytes
```
ŒìD·õÉŒûùêç}ùê¨
```
Explanation:
```
Œì        Apply the following to each element in the input array
 D         Duplicate
  ·õÉ        Modulo 2, then perform logical NOT
   Œû       If truthy, then:
    ùêç        Multiply by -1
      }  Close all currently running loops/conditionals etc
       ùê¨ Sum the resulting array
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 7 bytes
```
‚â†0·πÅ·π†!¬°_
```
[Try it online!](https://tio.run/##yygtzv7//1HnAoOHOxsf7lygeGhh/P///6MNdYx0jHVMYgE "Husk ‚Äì Try It Online")
Takes a list of digits as input.
Still missing an "abs" builtin, but a good result all the same :)
### Explanation
`·π†!¬°_` is a function that takes a number `n` and then applies `n-1` times the function `_` (negation) to `n`. This results in `n` for odd `n` or `-n` for even `n`.
`·πÅ` applies a function to each element of a list and sums the results.
`‚â†0` returns the absolute difference between a number and 0.
[Answer]
# APL, 8 bytes
```
|‚ä¢+.√ó¬Ø1*‚ä¢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhJpHXYu09Q5PP7TeUAvIBAoqGHClKRiCsIIRkDQGQSBtomCqYAmkjYAsMwVLAA)
**How?**
`¬Ø1*‚ä¢` - -1n for `n` in `‚çµ`
[`4 5 9` ‚Üí `1 ¬Ø1 ¬Ø1`]
`‚ä¢+.√ó` - verctorized multiplication with `o`, then sum
[`+/ 4 5 9 √ó 1 ¬Ø1 ¬Ø1` ‚Üí `+/ 4 ¬Ø5 ¬Ø9` ‚Üí `¬Ø10`]
`|` - absolute value
[Answer]
# Mathematica, 67 bytes
```
(s=#;Abs[Subtract@@(Tr@Select[IntegerDigits@s,#]&/@{EvenQ,OddQ})])&
```
[Answer]
## JavaScript (ES6), ~~43~~ 38 bytes
Takes input as ~~a string~~ an array of digits.
```
a=>a.map(d=>s+=d&1?d:-d,s=0)&&s>0?s:-s
```
### Test cases
```
let f =
a=>a.map(d=>s+=d&1?d:-d,s=0)&&s>0?s:-s
console.log(f([1]))     // ~> 1 ( |1-0| = 1)
console.log(f([0]))     // ~> 0 ( |0-0| = 0)
console.log(f([1,2]))    // ~> 1 ( |1-2| = 1)
console.log(f([4,5,9]))   // ~> 10 ( |4-(5+9)| = 10)
console.log(f([2,4,6,9]))  // ~> 3 ( |(2+4+6)-9| = 3)
console.log(f([3,3,3]))   // ~> 9 ( |(3+3+3)-0| = 9)
```
[Answer]
***EDIT: A more golf-centered approach:***
## EXCEL, 42 36 29 bytes
Saved 6 bytes thanks to Magic Octopus Urn
Saved 7 bytes by using Dennis' -1^ approach (which, I just learned, works on arrays in excel)
```
=ABS(SUMPRODUCT(A:A,-1^A:A))
```
Takes a list of integers in A column for input. Probably can be golfed further, or by using the string version, taking a string in A1 for input. 
## EXCEL, 256 bytes
```
=ABS(LEN(SUBSTITUTE(A1,1,""))-2*LEN(SUBSTITUTE(A1,2,""))+3*LEN(SUBSTITUTE(A1,3,""))-4*LEN(SUBSTITUTE(A1,4,""))+5*LEN(SUBSTITUTE(A1,5,""))-6*LEN(SUBSTITUTE(A1,6,""))+7*LEN(SUBSTITUTE(A1,7,""))-8*LEN(SUBSTITUTE(A1,8,""))+9*LEN(SUBSTITUTE(A1,9,""))-5*LEN(A1))
```
[![enter image description here](https://i.stack.imgur.com/ONy3a.png)](https://i.stack.imgur.com/ONy3a.png)
[Answer]
# [Julia 0.5](http://julialang.org/), 19 bytes
```
!x=(-1).^x‚ãÖx|>abs
```
[Try it online!](https://tio.run/##yyrNyUw0/f9fscJWQ9dQUy@u4lF3a0WNXWJS8f@0/CKFPIXMPAUNQx0DHUMjHWNjYx0TU0sdIxMzSyDf2ESTi9OhoCgzryRNQ0nVpFRB105B1ag0Jk9JRyFPR0ExJTM9s6RYI09Tkys1L@U/AA "Julia 0.5 ‚Äì Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
Thanks to [Dennis](https://codegolf.stackexchange.com/users/12012/dennis) for the -1 power trick. Takes input as a list of digits
```
¬Æsm*O√Ñ
```
[Try it online!](https://tio.run/##MzBNTDJM/f//0LriXC3/wy3//0eb6CiY6ihYxgIA "05AB1E ‚Äì Try It Online")
### Explanation
```
¬Æsm*O√Ñ                                               Example [4, 5, 9]
¬Æ      # Push -1                                   % STACK: -1
 sm    # Take -1 to the power of every number      % STACK: [1, -1, -1]
         in the input list 
   *   # Multiply with original input              % Multiply [1, -1, -1] with [4, 5, 9] results in STACK: [4, -5, -9]
    O  # Sum them all together                     % STACK: -10
     √Ñ # Absolute value                            % STACK: 10
       # Implicit print
```
[Answer]
# PHP, 51 bytes
```
while(~$n=$argn[$i++])$s+=$n&1?$n:-$n;echo abs($s);
```
adds digit to `$s` if odd, subtracts if even. Run as pipe with `-nR`.
or
```
while(~$n=$argn[$i++])$s+=(-1)**$n*$n;echo abs($s);
```
using Dennis¬¥ `-1` power trick.
[Answer]
# [PHP](https://php.net/), 54 bytes
```
for(;~$n=$argn[$i++];)${eo[$n&1]}+=$n;echo abs($e-$o);
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwKWSWJSeZ6tkYWhgaGJkrGT9Py2/SMO6TiXPFiwTrZKprR1rralSnZofrZKnZhhbq22rkmedmpyRr5CYVKyhkqqrkq9p/f8/AA "PHP ‚Äì Try It Online")
# [PHP](https://php.net/), 57 bytes
store the even and odd sums in an array
```
for(;~$n=$argn[$i++];)$r[$n&1]+=$n;echo abs($r[0]-$r[1]);
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwKWSWJSeZ6tkaGBoYmSsZP0/Lb9Iw7pOJc8WLBGtkqmtHWutqVIUrZKnZhirbauSZ52anJGvkJhUrAEUNYjVBZKGsZrW//8DAA "PHP ‚Äì Try It Online")
# [PHP](https://php.net/), 57 bytes
store the even and odd sums in two variables
```
for(;~$n=$argn[$i++];)$n&1?$o+=$n:$e+=$n;echo abs($e-$o);
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwKWSWJSeZ6tkaGBoYmSsZP0/Lb9Iw7pOJc8WLBGtkqmtHWutqZKnZmivkq9tq5JnpZIKoqxTkzPyFRKTijVUUnVV8jWt//8HAA "PHP ‚Äì Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 47 42 39 38 26 25 bytes
*-1 thanks to nimi*
*-12 thanks to Bruce*
*-1 thanks to xnor*
```
abs.sum.map(\x->x*(-1)^x)
```
[Try it online!](https://tio.run/##HclBC4IwAMXxe5/iMS9buJHOAg8KEuGlwkuntFg0SdIhmiBEn32tDu93eP@HGp@6be2be9hnx/yU5TtsiwIe/yzqpLTqNopx6kSnelrOPJ2XlAfsMjPbqcYggQuHK2hpwFP0Q2NeoMZHDeoK6KDVXfTToBkMYwxnsiI@CX4LHVJKZ7SOnWG0if@/jEhlvw "Haskell ‚Äì Try It Online")
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~18~~ ~~15~~ 12 bytes
```
#!+/{x-:/x}'
```
[Try it online!](https://ngn.codeberg.page/k#eJw1jctOwzAQRffzFYNAIlFw/UyRY8GeFR9QVSKkSVu1jUvsoFR9fDt2GjSLmTnnetwUjw8ZPQ+koMP1GcAX56fF6dYVDSIO5svuTPLVlNu9GczJdOnyCn7xwgxbxs4Nj52juA8SQxkdR4U5asPHnECF87DJKRxSyoglAIWN90dXUFrZVb22+2bmfFnt6qHalO26nlX2QH/62vmtbR3lkr/mOXX9t+/KypPDidjVypGms4e41L916wA+2mPv8faOn70PEwCLC8Pkwgi74BuyFHhEPCB+Rzwg8c8E4ROTUkaox7eJzEKlUekUVK7HfLyrSJJnejQ8HBdqPjoZVCIylc1ToqOU8RepohOTS0nCp6MiBfgDYCRoKQ==)
Takes input as a list of digits.
* `{x-:/x}'` negate each digit of the input that many times (e.g., negate `4` four times, and `9` nine times). this makes odd digits negative, leaving even digits positive
* `+/` take the sum
* `#!` take the absolute value (and implicitly return)
[Answer]
# [Perl 6](http://perl6.org/), 28 bytes
```
{abs sum $_ Z*.map(*%2*2-1)}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/OjGpWKG4NFdBJV4hSksvN7FAQ0vVSMtI11Cz9r@1QnFipUKaho2hgpGCsYKJnab1fwA "Perl 6 ‚Äì Try It Online")
Takes a list of digits as input.
* `$_` is the input argument.
* `.map(* % 2 * 2 - 1)` maps each digit to either `1` or `-1` depending on whether the digit is odd or even, respectively.
* `Z*` zips the original list of digits with the even/odd list using multiplication.
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 18 bytes
```
{.2%?M|}&+v&+c-!s*
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/@/Ws9I1d63plZNu0xNO1lXsVjr////hv@N/hv/N/lvCgA "Braingolf ‚Äì Try It Online")
Takes input as a list of digits
## Explanation
```
{.2%?M|}&+v&+c-!s*  Implicit input from commandline args
{......}            Foreach loop, runs on each item in the stack..
 .2%                ..Parity check, push 1 if odd, 0 if even
    ?               ..If last item != 0 (pops last item)..
     M              ....Move last item to next stack
      |             ..Endif
        &+          Sum entire stack
          v&+       Switch to next stack and sum entire stack
             c-     Collapse into stack1 and subtract
               !s   Sign check, push 1 if last item is positive, -1 if last item is
                    negative, 0 if last item is 0
                 *  Multiply last item by sign, gets absolute value
                    Implicit output
```
[Answer]
# R, ~~72~~ 43 bytes
```
b=(d=scan())%%2<1;abs(sum(d[b])-sum(d[!b]))
```
First, `d = scan()` takes the number as input, one digit after the other (thanks to @Giuseppe comment !)  
Then, `b = d %% 2 <1` associates to `b` a `TRUE` or `FALSE` value at each index depending on the digits' parity.
Therefore, `b` values are `TRUE` for even numbers, and `!b` are `TRUE` for odd values.
Finaly, `abs(sum(d[b]) - sum(d[!b]))` does the job.
[Answer]
# Bash ~~141~~ ~~139~~ 99 Bytes
```
while read -n1 a; do
[ $[a%2] = 0 ]&&e=$[e+a]||o=$[o+a]
done
(($[e-o]>0))&&echo $[e-o]||echo $[o-e]
```
[Try it online!](https://tio.run/##S0oszvj/vzwjMydVoSg1MUVBN89QIdFaISWfK1pBJTpR1ShWwVbBQCFWTS3VViU6VTsxtqYmH8jKB7K4UvLzUrk0NIDiuvmxdgaamkBVyRn5ChCBmhooJ183Nfb/fzMjY0sA)
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 32 bytes
```
00\~:00@(?$-n;
(?\c%:0@2%?$-+i:0
```
[Try it online!](https://tio.run/##S8sszvj/38Agps7KwMBBw15FN8@aS8M@JlnVysDBSBXI1860Mvj/38jEzBIA "><> ‚Äì Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 55 bytes
```
a->{int s=0;for(int d:a)s+=d%2<1?-d:d;return s<0?-s:s;}
```
[Try it online!](https://tio.run/##TVDLboMwELznK/ZSCVRjEUorlUeiXir10FN6i3JwMUSmxCB2SRUhfzs1jyaRDzsz3p0dbSnOwqubXJfyZ2i670plkFUCET6F0tCvABYVSZAt51pJONk/Z0et0sf9AUR7RHdqBSitH@9IVbzodEaq1vyr/tD0vrBEadofNlCkg/A2vWWAqR8XdeuMWEbCxcdUPgTJeuvJSMZtTl2rARN/62GEsRniadHkY5dTjoSQgs5/r9ocBaD3DfuH6zvIght5YvbdaMie2euNBixkL/eCnbUDoZm4maMs4Zcw0ZTIvYbYXZDyE6874o09GFXaKbhomuryhvYwztjuurPTaGtWZvgD "Java (OpenJDK 8) ‚Äì Try It Online")
Naive implementation.
[Answer]
# C#, 67 bytes
```
namespace System.Linq{a=>Math.Abs(a.Sum(n=>n%2<1)-a.Sum(n=>n%2>1))}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
```
√à2*<*O√Ñ
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cIeRlo2W/@GW//@jTXQUTHUULGMB "05AB1E ‚Äì Try It Online")
```
        # Input              | 1234567
√à       # Is Even?           | [0,1,0,1,0,1,0]
 2*<    # (a * 2) - 1        | [-1,1,-1,1,-1,1,-1]
    *   # Multiply w/ input. | [-1,2,-3,4,-5,6,-7]
     O  # Sum.               | -10
      √Ñ # Absolute value of. | 10
```
[Answer]
# x86-64 Machine Code, 30 bytes
```
31 C0 99 8B 4C B7 FC F6 C1 01 74 04 01 CA EB 02 01 C8 FF CE 75 ED 29 D0 99 31 D0 29 D0 C3
```
The above code defines a function that accepts a list/array of integer digits and returns the absolute difference between the sum of its even digits and the sum of its odd digits.
[As in C](https://codegolf.meta.stackexchange.com/questions/13210/list-input-in-c-and-length-argument), assembly language doesn't implement lists or arrays as first-class types, but rather represents them as a combination of a pointer and a length. Therefore, I have arranged for this function to accept two parameters: the first is a pointer to the beginning of the list of digits, and the second is an integer specifying the total length of the list (total number of digits, one-indexed).
The function conforms to the [System V AMD64 calling convention](https://en.wikipedia.org/wiki/X86_calling_conventions#System_V_AMD64_ABI), which is standard on Gnu/UNIX systems. In particular, the first parameter (pointer to the beginning of the list) is passed in `RDI` (as this is 64-bit code, it is a 64-bit pointer), and the second parameter (length of the list) is passed in `ESI` (this is only a 32-bit value, because that's more than enough digits to play with, and naturally it is assumed to be non-zero). The result is returned in the `EAX` register.
If it's any clearer, this would be the C prototype (and you can use this to call the function from C):
```
int OddsAndEvens(int *ptrDigits, int length);
```
**Ungolfed assembly mnemonics:**
```
; parameter 1 (RDI) == pointer to list of integer digits
; parameter 2 (ESI) == number of integer digits in list (assumes non-zero, of course)
OddsAndEvens:
   xor  eax, eax              ; EAX = 0 (accumulator for evens)
   cdq                        ; EDX = 0 (accumulator for odds)
.IterateDigits:
   mov  ecx, [rdi+rsi*4-4]    ; load next digit from list
   test cl, 1                 ; test last bit to see if even or odd
   jz   .IsEven               ; jump if last bit == 0 (even)
.IsOdd:                       ; fall through if last bit != 0 (odd)
   add  edx, ecx              ; add value to odds accumulator
   jmp  .Continue             ; keep looping
.IsEven:
   add  eax, ecx              ; add value to evens accumulator
.Continue:                    ; fall through
   dec  esi                   ; decrement count of digits in list
   jnz  .IterateDigits        ; keep looping as long as there are digits left
   sub  eax, edx              ; subtract odds accumulator from evens accumulator
   ; abs
   cdq                        ; sign-extend EAX into EDX
   xor  eax, edx              ; XOR sign bit in with the number
   sub  eax, edx              ; subtract sign bit
   ret                        ; return with final result in EAX
```
Here's a brief walk-through of the code:
* First, we zero out the `EAX` and `EDX` registers, which will be used to hold the sum totals of even and odd digits. The `EAX` register is cleared by `XOR`ing it with itself (2 bytes), and then the `EDX` register is cleared by sign-extending the EAX into it (`CDQ`, 1 byte).
* Then, we go into the loop that iterates through all of the digits passed in the array. It retrieves a digit, tests to see if it is even or odd (by testing the least-significant bit, which will be 0 if the value is even or 1 if it is odd), and then jumps or falls through accordingly, adding that value to the appropriate accumulator. At the bottom of the loop, we decrement the digit counter (`ESI`) and continue looping as long as it is non-zero (i.e., as long as there are more digits left in the list to be retrieved).
The only thing tricky here is the initial MOV instruction, which uses the most complex addressing mode possible on x86.\* It takes `RDI` as the base register (the pointer to the beginning of the list), scales `RSI` (the length counter, which serves as the index) by 4 (the size of an integer, in bytes) and adds that to the base, and then subtracts 4 from the total (because the length counter is one-based and we need the offset to be zero-based). This gives the address of the digit in the array, which is then loaded into the `ECX` register.
* After the loop has finished, we do the subtraction of the odds from the evens (`EAX -= EDX`).
* Finally, we compute the absolute value using a common trick‚Äîthe same one used by most C compilers for the `abs` function. I won't go into details about how this trick works here; see code comments for hints, or do a web search.
\_\_  
\* The code can be re-written to use simpler addressing modes, but it doesn't make it any shorter. I was able to come up with an alternative implementation that dereferenced `RDI` and incremented it by 8 each time through the loop, but because you still have to decrement the counter in `ESI`, this turned out to be the same 30 bytes. What had initially given me hope is that `add eax, DWORD PTR [rdi]` is only 2 bytes, the same as adding two enregistered values. Here is that implementation, if only to save anyone attempting to outgolf me some effort :-)
```
                    OddsAndEvens_Alt:
31 C0                   xor    eax, eax
99                      cdq
                    .IterateDigits:
F6 07 01                test   BYTE PTR [rdi], 1
74 04                   je     .IsEven
                    .IsOdd:
03 17                   add    edx, DWORD PTR [rdi]
EB 02                   jmp    .Continue
                    .IsEven:
03 07                   add    eax, DWORD PTR [rdi]
                    .Continue:
48 83 C7 08             add    rdi, 8
FF CE                   dec    esi
75 ED                   jne    .IterateDigits
29 D0                   sub    eax, edx
99                      cdq
31 D0                   xor    eax, edx
29 D0                   sub    eax, edx
C3                      ret
```
]