On 6/17/2022 1:45 PM, Mr Flibble wrote:
> On Fri, 17 Jun 2022 13:42:05 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/17/2022 12:14 PM, Mr Flibble wrote:
>>> On Fri, 17 Jun 2022 12:13:13 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8, olcott
>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
>>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
>>>>>>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
>>>>>>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when we
>>>>>>>>>>>>>>>>>>>>>>>> assume that H is only an x86 emulator that the
>>>>>>>>>>>>>>>>>>>>>>>> correctly emulated P never reaches its "ret"
>>>>>>>>>>>>>>>>>>>>>>>> instruction it remains stuck in repeated cycles
>>>>>>>>>>>>>>>>>>>>>>>> of emulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H has
>>>>>>>>>>>>>>>>>>>>>>>> been adapted to correctly detect (in a finite
>>>>>>>>>>>>>>>>>>>>>>>> number of steps) that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation of its input would never each its
>>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction that H could abort its
>>>>>>>>>>>>>>>>>>>>>>>> emulation and return 0 to report this.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined as
>>>>>>>>>>>>>>>>>>>>>>>> correctly determining whether or not an x86
>>>>>>>>>>>>>>>>>>>>>>>> emulated input would ever reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily verified
>>>>>>>>>>>>>>>>>>>>>>>> fact H(P,P) could correctly reject its input as
>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all of
>>>>>>>>>>>>>>>>>>>>>>>> these things are true without any need
>>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
>>>>>>>>>>>>>>>>>>>>>>>> the execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether or
>>>>>>>>>>>>>>>>>>>>>>>> not an actual encoded H(P,P) does indeed
>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would never
>>>>>>>>>>>>>>>>>>>>>>>> reach its "ret" instruction as a pure function
>>>>>>>>>>>>>>>>>>>>>>>> of its inputs. This aspect will be confirmed by
>>>>>>>>>>>>>>>>>>>>>>>> fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
>>>>>>>>>>>>>>>>>>>>>>> cannot exist:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from their
>>>>>>>>>>>>>>>>>>>>>> inputs to an accept or reject state on the basis
>>>>>>>>>>>>>>>>>>>>>> of the actual behavior actually specified by
>>>>>>>>>>>>>>>>>>>>>> these inputs.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
>>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of the input to
>>>>>>>>>>>>>>>>>>>>>> H(P,P) by H would never reach its "ret"
>>>>>>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
>>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
>>>>>>>>>>>>>>>>>>>>> test/review.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before because
>>>>>>>>>>>>>>>>>>>> I knew that its use of static local data would
>>>>>>>>>>>>>>>>>>>> have been rejected. With this update to H I will
>>>>>>>>>>>>>>>>>>>> be able to publish the code.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its same
>>>>>>>>>>>>>>>>>>>> arguments that it was called with and there are no
>>>>>>>>>>>>>>>>>>>> instructions preceding this call that could
>>>>>>>>>>>>>>>>>>>> possibly escape infinitely recursive emulation so
>>>>>>>>>>>>>>>>>>>> H aborts its emulation of P before P even makes
>>>>>>>>>>>>>>>>>>>> its first call to H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent software
>>>>>>>>>>>>>>>>>>>> engineers will be able to verify that the above H
>>>>>>>>>>>>>>>>>>>> would correctly determine that that is input is
>>>>>>>>>>>>>>>>>>>> non-halting as a pure function of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>>>> function for any accepted definition of the term.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>>>>>> identical arguments (no variation with local static
>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
>>>>>>>>>>>>>>>>>> arguments or input streams), and
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (2) the function application has no side effects (no
>>>>>>>>>>>>>>>>>> mutation of local static variables, non-local
>>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
>>>>>>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue of a
>>>>>>>>>>>>>>>>>> mathematical function.
>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure functions
>>>>>>>>>>>>>>> do not have side effects.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Whether or not it is construed as a side-effect does not
>>>>>>>>>>>>>> matter it must be a mutation side-effect to (a)(b)(c)(d)
>>>>>>>>>>>>>> or it does not count.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>>
>>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>>
>>>>>>>>>>> "In computer science, an operation, function or expression
>>>>>>>>>>> is said to have a side effect if it modifies some state
>>>>>>>>>>> variable value(s) outside its local environment,
>>>>>>>>>>
>>>>>>>>>> The second part is an inaccurate paraphrase of the first
>>>>>>>>>> part.
>>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>>> other than its primary effect of returning a value to the
>>>>>>>>>>> invoker of the operation." --
>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>>
>>>>>>>>>>> "any observable effect"
>>>>>>>>>>>
>>>>>>>>>>> Aborting the simulation instead of returning a value to the
>>>>>>>>>>> invoker disqualifies it from being a pure function.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> if (H(x, x))
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>
>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its machine
>>>>>>>>>> address of [0000135d] the very first time before the code at
>>>>>>>>>> this address is emulated. Then H returns 0 to its caller:
>>>>>>>>>> main().
>>>>>>>>>
>>>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>>>
>>>>>>>>> Again:
>>>>>>>>>
>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>> not have side effects.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Do you have ADD?
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>> }
>>>>>>>
>>>>>>> If your claim is that H is only called once and the second time
>>>>>>> an *attempt* to call H is prevented than that is equivalent to
>>>>>>> calling H and having H do something different with side effects.
>>>>>>> This is just my opinion though as it requires more thought and I
>>>>>>> am currently getting drunk on gin and tonics.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> It is obviously the exact same pattern as infinite recursion
>>>>>> (a) calling the same function a second time with the same
>>>>>> arguments and
>>>>>>
>>>>>> (b) there are no instructions preceding this call that could
>>>>>> possibly escape the infinite recursion / infinitely recursive
>>>>>> emulation.
>>>>>
>>>>> Agree but refusing to analyse what P would have done if H wasn't a
>>>>> simulating decider still makes what you've got worthless as far as
>>>>> the Halting Problem is concerned.
>>>>>
>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>>>>>
>>>>
>>>> It is dead obvious to everyone (even Richard) that what P would
>>>> have done if H was merely an x86 emulator and not a halt deciding
>>>> emulator.
>>>>
>>>> The correct and complete x86 emulation of H(P,P) would never reach
>>>> its "ret" instruction thus making H a correct "not reach ret" /
>>>> halt decider for P.
>>>
>>> You need to think about a P that calls H but is non-pathological
>>> halting (no infinite loop).
>>>
>>> /Flibble
>>>
>>
>> I have already done that and posted all of the details here about
>> three dozen times.
>>
>> void P(ptr x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H1(P, P));
>> }
>>
>> It remains true that the correct and complete x86 emulation of the
>> input to H(P,P) by H never reaches its "ret" instruction thus never
>> halts.
>
> Try reading what I actually wrote:
>
> void P(ptr x)
> {
> H(x, x); // ignore result
> return; // halt
> }
>
> How does your "decider" handle that P?
>
> /Flibble
>

Removing the infinite loop does not make it non pathological.
As I have said donzens of times the infinite loop is unreachable.

void Px(u32 x)
{ H(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H((u32)Px, (u32)Px));
}

_Px()
[000013b6](01) 55 push ebp
[000013b7](02) 8bec mov ebp,esp
[000013b9](03) 8b4508 mov eax,[ebp+08]
[000013bc](01) 50 push eax
[000013bd](03) 8b4d08 mov ecx,[ebp+08]
[000013c0](01) 51 push ecx
[000013c1](05) e8e0fdffff call 000011a6
[000013c6](03) 83c408 add esp,+08
[000013c9](01) 5d pop ebp
[000013ca](01) c3 ret
Size in bytes:(0021) [000013ca]

_main()
[000013d6](01) 55 push ebp
[000013d7](02) 8bec mov ebp,esp
[000013d9](05) 68b6130000 push 000013b6
[000013de](05) 68b6130000 push 000013b6
[000013e3](05) e8befdffff call 000011a6
[000013e8](03) 83c408 add esp,+08
[000013eb](01) 50 push eax
[000013ec](05) 6827040000 push 00000427
[000013f1](05) e880f0ffff call 00000476
[000013f6](03) 83c408 add esp,+08
[000013f9](02) 33c0 xor eax,eax
[000013fb](01) 5d pop ebp
[000013fc](01) c3 ret
Size in bytes:(0039) [000013fc]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
....[000013d6][00102357][00000000] 55 push ebp
....[000013d7][00102357][00000000] 8bec mov ebp,esp
....[000013d9][00102353][000013b6] 68b6130000 push 000013b6
....[000013de][0010234f][000013b6] 68b6130000 push 000013b6
....[000013e3][0010234b][000013e8] e8befdffff call 000011a6

Begin Local Halt Decider Simulation Execution Trace Stored at:21240b
....[000013b6][002123f7][002123fb] 55 push ebp
....[000013b7][002123f7][002123fb] 8bec mov ebp,esp
....[000013b9][002123f7][002123fb] 8b4508 mov eax,[ebp+08]
....[000013bc][002123f3][000013b6] 50 push eax
....[000013bd][002123f3][000013b6] 8b4d08 mov ecx,[ebp+08]
....[000013c0][002123ef][000013b6] 51 push ecx
....[000013c1][002123eb][000013c6] e8e0fdffff call 000011a6
....[000013b6][0025ce1f][0025ce23] 55 push ebp
....[000013b7][0025ce1f][0025ce23] 8bec mov ebp,esp
....[000013b9][0025ce1f][0025ce23] 8b4508 mov eax,[ebp+08]
....[000013bc][0025ce1b][000013b6] 50 push eax
....[000013bd][0025ce1b][000013b6] 8b4d08 mov ecx,[ebp+08]
....[000013c0][0025ce17][000013b6] 51 push ecx
....[000013c1][0025ce13][000013c6] e8e0fdffff call 000011a6
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

....[000013e8][00102357][00000000] 83c408 add esp,+08
....[000013eb][00102353][00000000] 50 push eax
....[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
....[000013f6][00102357][00000000] 83c408 add esp,+08
....[000013f9][00102357][00000000] 33c0 xor eax,eax
....[000013fb][0010235b][00100000] 5d pop ebp
....[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer