On Fri, 10 Jun 2022 10:29:54 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/10/2022 10:19 AM, Mr Flibble wrote:
> > On Fri, 10 Jun 2022 10:15:52 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/10/2022 10:06 AM, Mr Flibble wrote:
> >>> On Fri, 10 Jun 2022 09:54:10 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
> >>>>> On Fri, 10 Jun 2022 09:43:47 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/10/2022 9:37 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 10 Jun 2022 09:32:47 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/10/2022 9:21 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 10 Jun 2022 09:15:29 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/10/2022 9:03 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 10 Jun 2022 08:59:17 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/10/2022 8:51 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 10 Jun 2022 08:43:48 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/10/2022 8:35 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:33:27 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 6/10/2022 8:29 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:27:28 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 6/10/2022 8:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:05:57 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 6/10/2022 6:11 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:35:05 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 5:27 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:18:38 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 5:15 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:09:08 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 4:54 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 5:29 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 4:13 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 5:00 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 3:25 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 2:57 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 2:38 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 3:26 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500 olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:28 PM, Mr
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500 olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      if
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (H(x, x)) HERE: goto
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE; return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>      P(P);
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7](01)  55
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [000012e8](02)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea](03) 8b4508
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed](01)  50 push
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax [000012ee](03)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1](01) 51 push
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx [000012f2](05)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 00001177 // call H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f7](03) 83c408
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fa](02) 85c0
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fc](02) 7402 jz
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 00001300
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012fe](02) ebfe
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000012fe
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001300](01) 5d pop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp [00001301](01) c3
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0027) [00001301]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307](01)  55
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp [00001308](02)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a](05)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f](05)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001314](03) 83c404
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+04
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001317](02) 33c0
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001319](01) 5d pop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp [0000131a](01) c3
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bytes:(0020) [0000131a]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>     machine
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stack stack machine
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assembly address
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> address data code
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language =======> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ======== =======> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ========= ============> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001308][00102190][00000000]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a][0010218c][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130f][00102188][00001314]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e8d3ffffff call
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00102184][00102190]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp // enter
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][00102184][00102190]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][00102180][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0010217c][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 00001177 // call H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Begin Local Halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Decider Simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Execution Trace Stored
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][00212230][00212234]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp // enter
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulated P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][00212230][00212234]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax      //
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0021222c][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][00212228][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 00001177 // call H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, by what instruction
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reference manual is a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> followedby the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction at 000012e7.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Your "CPU" is broken, or
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][0025cc58][0025cc5c]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp      //
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea][0025cc58][0025cc5c]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 50 push eax      //
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee][0025cc54][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1][0025cc50][000012e7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880feffff call
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 00001177 // call H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Local Halt Decider:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Stopped
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is completely
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> obvious that when
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulates its input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it must emulate
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the first seven
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the seventh
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction of P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know with complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> certainty that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never reach its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final “ret”
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, the 7th
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> intruction DOESN't "Just
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeat the procedure",
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because that H always
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has the option to abort
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation, just
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> like this onne did, and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return to its P and see
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> STUPID TO UNDERSTAND THIS
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL REBUTTAL AT
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ALL:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The partial correct x86
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of the input to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and correct x86 emulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never stop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You SAY that, but you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't answer the actual
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> questions about HOW.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> STUPID TO UNDERSTAND THIS
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IS NO EVIDENCE WHAT-SO-EVER
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT I DID NOT COMPLETELY
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PROVE THAT THE CORRECT
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT TO H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> X86 EMULATION OF THE INPUT
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TO H(P,P) WOULD NEVER STOP
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> RUNNING.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is completely obvious
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that when H(P,P) correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulates its input that it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must emulate the first
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seven instructions of P.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because the seventh
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction of P repeats
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this process we know with
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete certainty that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its final
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If P should have halted
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (i.e. no infinite loop)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then your simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the answer wrong. You S is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT a halting decider.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> STUPID TO UNDERSTAND THIS IS
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NO ACTUAL REBUTTAL AT ALL.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _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]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is completely obvious that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H(P,P) correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulates its input that it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must emulate the first seven
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions of P. Because
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the seventh instruction of P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeats this process we know
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with complete certainty that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its final “ret”
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are going around and around
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and around in circles. I will
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try again:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you replace the opcodes "EB
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FE" at 00001369 with the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> opcodes "90 90" then your H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> gets the answer wrong: P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should have halted.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I already said before this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is merely your cluelessness
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that when H(P,P) is invoked the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) makes and code
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> after [0000135d] unreachable.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong, because when that H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return the value 0, it will get
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Like I said people that are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box of rocks won't
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be able to correctly understand
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When H(P,P) is invoked the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulated input to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) cannot possibly reach any
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction beyond [0000135d].
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you are defining that you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) never returns because it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is caught in the infinite
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rcursion.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thats fine, just says it can't be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the correctly answering decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claim it to be.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have corrected you on this too
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> many times.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> How. You need to define what H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually does.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have explained that too many times.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To understand that H(P,P)==0 is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct we only need to know that H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> performs a correct x86 emulation of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input and then examine the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution trace.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And a CORRECT emulation of the code
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will Halt if H(P,P) returns 0, which
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it can only do if it does not
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually do a correct emulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correctly emulated input to H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never gets past its machine address
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d].
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Only if H actually doesn't return 0.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, H can't correctly return 0 if it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates its input, but you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't drop that requirement.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>    if (H(x, x))
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>    return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)P, (u32)P)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> When H returns 0 it does not returns 0
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> to P it returns 0 to main().
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> But it also return 0 to the computation
> >>>>>>>>>>>>>>>>>>>>>>>>>>> P(P), maybe not the copy that it is
> >>>>>>>>>>>>>>>>>>>>>>>>>>> simulating, since it aborts that before it
> >>>>>>>>>>>>>>>>>>>>>>>>>>> get to it,
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Finally you are not stupid or deceptive.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> If H never returns a value to P then H is
> >>>>>>>>>>>>>>>>>>>>>>>>> not a halting decider; if H returns a value
> >>>>>>>>>>>>>>>>>>>>>>>>> of 0 to main() when P halts then H is not a
> >>>>>>>>>>>>>>>>>>>>>>>>> halting decider.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> H is not a halting decider; H is a
> >>>>>>>>>>>>>>>>>>>>>>>>> simulation detector, S.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> In other words you are saying the infintely
> >>>>>>>>>>>>>>>>>>>>>>>> nested emulation only excutes for a few steps
> >>>>>>>>>>>>>>>>>>>>>>>> and then it stops on its own.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> I am saying that your H is not a halting
> >>>>>>>>>>>>>>>>>>>>>>> decider; I am saying that your H is just a
> >>>>>>>>>>>>>>>>>>>>>>> simulation detector, S.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> You are saying that you simply "don't believe
> >>>>>>>>>>>>>>>>>>>>>> in" simulating halt deciders.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> You haven't got a simulating halt decider, what
> >>>>>>>>>>>>>>>>>>>>> you have got is a simulation detector.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> It is an easily verified fact that H does
> >>>>>>>>>>>>>>>>>>>> correctly decide the halt status of its input.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop)); }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>> [00001342](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>> [00001343](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>> [00001345](02) ebfe jmp 00001345
> >>>>>>>>>>>>>>>>>>>> [00001347](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>> [00001348](01) c3 ret
> >>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001348]
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>>>>>>>> [00001372](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>> [00001373](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>> [00001375](05) 6842130000 push 00001342
> >>>>>>>>>>>>>>>>>>>> [0000137a](05) e833fdffff call 000010b2
> >>>>>>>>>>>>>>>>>>>> [0000137f](03) 83c404 add esp,+04
> >>>>>>>>>>>>>>>>>>>> [00001382](01) 50 push eax
> >>>>>>>>>>>>>>>>>>>> [00001383](05) 6823040000 push 00000423
> >>>>>>>>>>>>>>>>>>>> [00001388](05) e8e5f0ffff call 00000472
> >>>>>>>>>>>>>>>>>>>> [0000138d](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>>>> [00001390](02) 33c0 xor eax,eax
> >>>>>>>>>>>>>>>>>>>> [00001392](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>> [00001393](01) c3 ret
> >>>>>>>>>>>>>>>>>>>> Size in bytes:(0034) [00001393]
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> machine stack stack machine
> >>>>>>>>>>>>>>>>>>>> assembly address address data code
> >>>>>>>>>>>>>>>>>>>> language ======== ======== ======== ========> >>>>>>>>>>>>>>>>>>>> ============= [00001372][0010228f][00000000] 55
> >>>>>>>>>>>>>>>>>>>> push ebp [00001373][0010228f][00000000] 8bec
> >>>>>>>>>>>>>>>>>>>> mov ebp,esp [00001375][0010228b][00001342]
> >>>>>>>>>>>>>>>>>>>> 6842130000 push 00001342 // push _Infinite_Loop
> >>>>>>>>>>>>>>>>>>>> [0000137a][00102287][0000137f] e833fdffff call
> >>>>>>>>>>>>>>>>>>>> 000010b2 // call H0
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation Execution
> >>>>>>>>>>>>>>>>>>>> Trace Stored at:212343
> >>>>>>>>>>>>>>>>>>>> [00001342][00212333][00212337] 55 push ebp
> >>>>>>>>>>>>>>>>>>>> [00001343][00212333][00212337] 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>> [00001345][00212333][00212337] ebfe jmp 00001345
> >>>>>>>>>>>>>>>>>>>> [00001345][00212333][00212337] ebfe jmp 00001345
> >>>>>>>>>>>>>>>>>>>> Local Halt Decider: Infinite Loop Detected
> >>>>>>>>>>>>>>>>>>>> Simulation Stopped
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> [0000137f][0010228f][00000000] 83c404 add
> >>>>>>>>>>>>>>>>>>>> esp,+04 [00001382][0010228b][00000000] 50
> >>>>>>>>>>>>>>>>>>>> push eax [00001383][00102287][00000423]
> >>>>>>>>>>>>>>>>>>>> 6823040000 push 00000423
> >>>>>>>>>>>>>>>>>>>> [00001388][00102287][00000423] e8e5f0ffff call
> >>>>>>>>>>>>>>>>>>>> 00000472 Input_Halts = 0
> >>>>>>>>>>>>>>>>>>>> [0000138d][0010228f][00000000] 83c408 add
> >>>>>>>>>>>>>>>>>>>> esp,+08 [00001390][0010228f][00000000] 33c0 xor
> >>>>>>>>>>>>>>>>>>>> eax,eax [00001392][00102293][00100000] 5d pop
> >>>>>>>>>>>>>>>>>>>> ebp [00001393][00102297][00000004] c3 ret Number
> >>>>>>>>>>>>>>>>>>>> of Instructions Executed(680)
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int Sum(int X, int Y)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> return X + Y;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H2(Sum, 3,
> >>>>>>>>>>>>>>>>>>>> 4)); }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> _Sum()
> >>>>>>>>>>>>>>>>>>>> [000012b6](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>> [000012b7](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>> [000012b9](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>> [000012bc](03) 03450c add eax,[ebp+0c]
> >>>>>>>>>>>>>>>>>>>> [000012bf](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>> [000012c0](01) c3 ret
> >>>>>>>>>>>>>>>>>>>> Size in bytes:(0011) [000012c0]
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>>>>>>>> [00001316](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>> [00001317](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>> [00001319](02) 6a04 push +04
> >>>>>>>>>>>>>>>>>>>> [0000131b](02) 6a03 push +03
> >>>>>>>>>>>>>>>>>>>> [0000131d](05) 68b6120000 push 000012b6
> >>>>>>>>>>>>>>>>>>>> [00001322](05) e85ffaffff call 00000d86
> >>>>>>>>>>>>>>>>>>>> [00001327](03) 83c40c add esp,+0c
> >>>>>>>>>>>>>>>>>>>> [0000132a](01) 50 push eax
> >>>>>>>>>>>>>>>>>>>> [0000132b](05) 6807040000 push 00000407
> >>>>>>>>>>>>>>>>>>>> [00001330](05) e821f1ffff call 00000456
> >>>>>>>>>>>>>>>>>>>> [00001335](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>>>> [00001338](02) 33c0 xor eax,eax
> >>>>>>>>>>>>>>>>>>>> [0000133a](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>> [0000133b](01) c3 ret
> >>>>>>>>>>>>>>>>>>>> Size in bytes:(0038) [0000133b]
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> machine stack stack machine
> >>>>>>>>>>>>>>>>>>>> assembly address address data code
> >>>>>>>>>>>>>>>>>>>> language ======== ======== ======== ========> >>>>>>>>>>>>>>>>>>>> ============= ...[00001316][001021d7][00000000]
> >>>>>>>>>>>>>>>>>>>> 55 push ebp ...[00001317][001021d7][00000000]
> >>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>> ...[00001319][001021d3][00000004] 6a04 push +04
> >>>>>>>>>>>>>>>>>>>> ...[0000131b][001021cf][00000003] 6a03 push +03
> >>>>>>>>>>>>>>>>>>>> ...[0000131d][001021cb][000012b6] 68b6120000
> >>>>>>>>>>>>>>>>>>>> push 000012b6 ...[00001322][001021c7][00001327]
> >>>>>>>>>>>>>>>>>>>> e85ffaffff call 00000d86
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation Execution
> >>>>>>>>>>>>>>>>>>>> Trace Stored at:21228b
> >>>>>>>>>>>>>>>>>>>> ...[000012b6][00212273][00212277] 55 push ebp
> >>>>>>>>>>>>>>>>>>>> ...[000012b7][00212273][00212277] 8bec mov
> >>>>>>>>>>>>>>>>>>>> ebp,esp ...[000012b9][00212273][00212277] 8b4508
> >>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>> ...[000012bc][00212273][00212277] 03450c add
> >>>>>>>>>>>>>>>>>>>> eax,[ebp+0c] ...[000012bf][00212277][00000e54]
> >>>>>>>>>>>>>>>>>>>> 5d pop ebp ...[000012c0][0021227b][00000003] c3
> >>>>>>>>>>>>>>>>>>>> ret ...[00001327][001021d7][00000000] 83c40c
> >>>>>>>>>>>>>>>>>>>> add esp,+0c ...[0000132a][001021d3][00000001] 50
> >>>>>>>>>>>>>>>>>>>> push eax ...[0000132b][001021cf][00000407]
> >>>>>>>>>>>>>>>>>>>> 6807040000 push 00000407
> >>>>>>>>>>>>>>>>>>>> ---[00001330][001021cf][00000407] e821f1ffff call
> >>>>>>>>>>>>>>>>>>>> 00000456 Input_Halts = 1
> >>>>>>>>>>>>>>>>>>>> ...[00001335][001021d7][00000000] 83c408
> >>>>>>>>>>>>>>>>>>>> add esp,+08 ...[00001338][001021d7][00000000]
> >>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
> >>>>>>>>>>>>>>>>>>>> ...[0000133a][001021db][00100000] 5d pop ebp
> >>>>>>>>>>>>>>>>>>>> ...[0000133b][001021df][00000004] c3 ret Number
> >>>>>>>>>>>>>>>>>>>> of Instructions Executed(660)
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> All you are showing here is that your H can decide
> >>>>>>>>>>>>>>>>>>> the halt status of two trivial cases however you
> >>>>>>>>>>>>>>>>>>> have not shown that H can decide the halt status
> >>>>>>>>>>>>>>>>>>> of non-trivial cases.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You said:
> >>>>>>>>>>>>>>>>>> "You haven't got a simulating halt decider"
> >>>>>>>>>>>>>>>>>> Apologize and we can move on.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> I posted four paragraphs but you ignored three of
> >>>>>>>>>>>>>>>>> them. Lets try again.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> It seems I need to try again. Perhaps it will help if
> >>>>>>>>>>>>>>> I combine the four paragraphs into a single paragraph:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> All you are showing here is that your H can decide the
> >>>>>>>>>>>>>>> halt status of two trivial cases however you have not
> >>>>>>>>>>>>>>> shown that H can decide the halt status of non-trivial
> >>>>>>>>>>>>>>> cases.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H is a halt decider for a subset of its inputs.
> >>>>>>>>>>>>>> H is a halt decider for P.
> >>>>>>>>>>>>>> When H is a halt decider for P all of the conventional
> >>>>>>>>>>>>>> halting problem proofs have been refuted.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> For H to be a halt decider it needs to be a halt decider
> >>>>>>>>>>>>> for all inputs not a subset.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Publish the source code of your halt
> >>>>>>>>>>>>>>> decider so we can see what classes of programs your H
> >>>>>>>>>>>>>>> can decide. I am interested in deciding the halt
> >>>>>>>>>>>>>>> status of programs containing non-trivial branching
> >>>>>>>>>>>>>>> logic predicated on arbitrary program input.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> These are out-of-scope.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> You may assert this but that doesn't make your assertion
> >>>>>>>>>>>>> true. If they are out-of-scope then your H is out of
> >>>>>>>>>>>>> scope of the Halting Problem.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Crucially if your H cannot return an answer for an
> >>>>>>>>>>>>>>> arbitrary non-halting program in finite time then it
> >>>>>>>>>>>>>>> isn't a halt decider.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> One can either say that H is a halt decider for a
> >>>>>>>>>>>>>> subset of its inputs or that H is a halt determiner.
> >>>>>>>>>>>>>> As long as H(P,P) correctly decides its input all of
> >>>>>>>>>>>>>> the conventional HP proofs have been refuted.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If we are to make progress you need to publish the code
> >>>>>>>>>>>>> of your infinite loop detector.
> >>>>>>>>>>>>
> >>>>>>>>>>>> If you can't understand 14 lines of code then this
> >>>>>>>>>>>> conclusively proves that you won't understand hundreds of
> >>>>>>>>>>>> pages of code.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Because people here are only interested in rebuttal and
> >>>>>>>>>>>> don't give a rat's ass about an honest dialogue I make
> >>>>>>>>>>>> the price of a continued dialogue key points of mutual
> >>>>>>>>>>>> agreement.
> >>>>>>>>>>>>
> >>>>>>>>>>>> If you don't understand that H(P,P)==0 is correct then
> >>>>>>>>>>>> providing the source code will only provide the means for
> >>>>>>>>>>>> denigration based on lack of comprehension. I absolutely
> >>>>>>>>>>>> will not tolerate that.
> >>>>>>>>>>>
> >>>>>>>>>>> If we are to make progress you need to publish the source
> >>>>>>>>>>> code of how your infinite loop detector works as your
> >>>>>>>>>>> disassembly traces DO NOT provide that information.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> I will not do that until many many points of mutual
> >>>>>>>>>> agreement have occurred. Until many many points of mutual
> >>>>>>>>>> agreement have occurred my assessment that my reviewers
> >>>>>>>>>> are lying cheating bastards remains affirmed.
> >>>>>>>>>
> >>>>>>>>> At this point, as you refuse to provide evidence to the
> >>>>>>>>> contrary, I conclude that the only case of non-halting
> >>>>>>>>> behavior you can detect are the execution of the Intel x86
> >>>>>>>>> opcodes "EB FE". Being only able to detect a single case of
> >>>>>>>>> non-halting behavior out of a total 2^n cases obviously does
> >>>>>>>>> not qualify as a halting decider.
> >>>>>>>>>
> >>>>>>>>> You know what you must do to refute this conclusion: provide
> >>>>>>>>> evidence in the form of source code.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> That I prove that H(P,P)==0 by itself refutes the halting
> >>>>>>>> problem proofs that claim that neither 0 nor 1 is correct.
> >>>>>>>
> >>>>>>> Your H gets the answer wrong if P would have halted as only
> >>>>>>> your
> >>>>>>
> >>>>>> That people with shit for brains think that is gets the wrong
> >>>>>> answer is no rebuttal at all.
> >>>>>
> >>>>> Shit for brains? Your insults are definitely increasing in
> >>>>> intensity, have you checked your blood pressure recently?
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> My proof has gotten down to the point that it is proven correct
> >>>> on the basis of easily verified facts. Lying cheating bastards
> >>>> disagree with these easily verified facts.
> >>>
> >>> Why don't you just take a step back for a minute and consider what
> >>> if you are wrong and there isn't actually a grand conspiracy of
> >>> liars acting against you?
> >>
> >> When I say that H(P,P)==0 on the basis of the actual behavior of
> >> the actual input all of the rebuttals are of the form that H is
> >> wrong on the basis of the behavior of a non-input.
> >
> > A halting P isn't non-input though; your H gets the answer wrong if
> > P would have halted after calling H and H isn't a recursive call
> > into a simulator.
> >
> > /Flibble
> >
>
> You don't even understand the simple concept of unreachable code.

I do though.

>
> It is an easily verified fact that the actual behavior of the actual
> input to H(P,P) conclusively proves that it never reaches its "ret"
> instruction thus never halts.

Unless P is a program which halts after calling H.

>
> The complete and correct x86 emulation of the input to H(P,P) by H
> would never stop running.

Not if P halts, i.e. invokes the decider but doesn't then pathologically
flip the result.

/Flibble