From Newsgroup: comp.lang.c++

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/3/2025 10:07 PM, olcott wrote:

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

Suppose we accept that HHH is able to correctly determine that replacing
the code of HHH with an unconditional simulator and running HHH(DD) will
not halt.

Then what?
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/3/2025 9:33 PM, dbush wrote:

On 3/3/2025 10:07 PM, olcott wrote:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

Suppose we accept that HHH is able to correctly determine that replacing
the code of HHH with an unconditional simulator and running HHH(DD) will
not halt.

Then what?

That is not a valid rebuttal and your paraphrase of
these words is inaccurate:

DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

Am 04.03.2025 um 04:07 schrieb olcott:

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

You're wrong; your program will never stop - like
your halting problem investigations.
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 04/03/2025 10:06, Bonita Montero wrote:

<snip>

You're wrong; your program will never stop

Yes, it will.

- like
your halting problem investigations.

Patience, patience. That, too, will stop... eventually.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/3/25 10:07 PM, olcott wrote:

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

And the HHH that correctly emulated DD, can't be a decider and answer.

Also. "the HHH", defined in your Halt7.c doesn't do that, so your claim
is based on the belief in a Truth Fairy that can make false statements true.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

Nope, *YOU* the one making the claims, need to show your proof, and
answer the questions.

Your failure to do so is just an admission thaty you KNOW you ar just a
liar and are deliberately makeing up stuff.

Some of the big ones that you are admitting to be errors because you do
not answer them:

How can HHH's simulation of the HHH called by DD be correct when it
doesn't match the trace of the execution of the outer HHH, but judt
stops the simulation claiming something that has not been proven?

If the behavior of a program can depend on its execution context, as you claim, then where is the first instruction, correctly simulated, where
that difference occurs? This simple fact just proves that you are
totally ignorant of the basics of Computing, and are working in some hair-brained logic system that isn't valid.

How can HHH be a proper "Pure Program" and still emulate the input you
claim to be giving it?

Remember, Pure Programs are not allowed to look at any data that isn't
part of their input or derived from their processing of it.

So, If the input is exactly what you show, how can HHH continue past the
Call HHH instruction as REQURIED to be a correct emulator when the data
isn't there.

If we include the code for HHH as part of the input, your claim that HHH
is just an emulator is proven FALSE, as the HHH that is there is the
decider that WILL abort its processing an return.

IF HHH is going to emulate the call based on just a description of HHH,
then it needs to be a correct description, and since this HHH WILL abort
and return, the description of the HHH that DD calls must also be that
it will do that, and thus you claims are shown to be just pure lies.

In all, all you have done is proved that you are ignorant of what you
talk about, not understand even the basic definitons and rules of the
system, but just don't care, because it seems, you are nothing but a pathological liar that has a reckless disregard for the truth.

--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

No, your are just totally ignoring the ERRORS and LIES pointed out in
your arguement, because you just don't care about what is true, but are
just a pathological liar with a reckess


On 3/3/25 10:07 PM, olcott wrote:

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

And that DD can not be "correctly emualted" by HHH, as it isn't a
complete program.

When you include HHH in that code, we first find that you currect design
of HHH doesn't "correctly emulate" its input, but aborts it based on a
false assumption about what the input does.

And, if we change HHH to meet that specification, YOU have proven that
it will not answer, and thus not be a decider.

The problem is you don't understand the question your HHH is supposed to
be answering, but have replaced it with a strawman, and apparently you
have straw for your brain.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

Nope, YOU need to show that you understand the errors you dismissed.

All you are doing is proving that you are just a ignorant pathological
lying idiot with a reckless disregard for the truth,

That will be how you are remembered for eternity,
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/4/2025 4:06 AM, Bonita Montero wrote:

Am 04.03.2025 um 04:07 schrieb olcott:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

You're wrong; your program will never stop - like
your halting problem investigations.

I am not wrong and no one can show that I wrong

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction. NO ONE CAN DO THAT BECAUSE I AM CORRECT
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/4/2025 6:29 AM, Richard Damon wrote:

On 3/3/25 10:07 PM, olcott wrote:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

*Proves that the input to HHH(DD) can be rejected as non-halting*

And the HHH that correctly emulated DD, can't be a decider and answer.

Also. "the HHH", defined in your Halt7.c doesn't do that,

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

Failing to provide the above proves that you are clueless
about this code.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenh


auer
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On Tue, 4 Mar 2025 08:21:39 -0600
olcott <polcott333@gmail.com> wibbled:

On 3/4/2025 4:06 AM, Bonita Montero wrote:

Am 04.03.2025 um 04:07 schrieb olcott:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

You're wrong; your program will never stop - like
your halting problem investigations.

I am not wrong and no one can show that I wrong

You're making the assertion, so YOU need to prove the program will halt,
its not for others to prove that it won't.


--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 04/03/2025 14:32, olcott wrote:

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

If that is the only rebuttal you are prepared to accept as valid, congratulations! You have solved the Halting Problem entirely to
your own satisfaction.

If you want to be recognised for your breakthrough, however, it
is not enough that nobody should convince you that you're wrong;
you have to convince others that you're right, and that means
explaining exactly why their criticisms are ill-founded. Saying
"I'm right and I won't listen to anyone claiming otherwise" lacks
explanatory power.

F'ups set.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/4/2025 8:43 AM, Muttley@DastardlyHQ.org wrote:

On Tue, 4 Mar 2025 08:21:39 -0600
olcott <polcott333@gmail.com> wibbled:

On 3/4/2025 4:06 AM, Bonita Montero wrote:

Am 04.03.2025 um 04:07 schrieb olcott:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

You're wrong; your program will never stop - like
your halting problem investigations.

I am not wrong and no one can show that I wrong

You're making the assertion, so YOU need to prove the program will halt,
its not for others to prove that it won't.

The code proves that DD correctly emulated by HHH
cannot possibly reach its own "ret" instruction and
terminate normally. This proves that HHH(DD) is correct
to reject its input as non-terminating.

If this is incorrect then someone could point out exactly
how DD correctly emulated by HHH would reach its own "ret"
instruction.

Changing my works and rebutting these changed words is
known as the straw-man deception.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/4/25 9:32 AM, olcott wrote:

On 3/4/2025 6:29 AM, Richard Damon wrote:

On 3/3/25 10:07 PM, olcott wrote:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

*Proves that the input to HHH(DD) can be rejected as non-halting*

No, it proves that the HHH that rejects the input, didn't do a correct simulation, and thus was looking at the wrong input, because you don't understand what a program is.

DD only is non-halting if *THE* HHH (and there is only one at any time)
never aborts. SInce HHH musts abort its emulation to "reject" the input,
it proves it didn't do the needed correct emulation, and you are shown
to be just a blantant liar.

And the HHH that correctly emulated DD, can't be a decider and answer.

Also. "the HHH", defined in your Halt7.c doesn't do that,

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

Failing to provide the above proves that you are clueless
about this code.

Nope, I have shown why your logic is wrong, and your insistance on a
strawman just proves you just have straw for brains.

--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

On 3/4/2025 5:45 PM, Richard Damon wrote:

On 3/4/25 9:32 AM, olcott wrote:

On 3/4/2025 6:29 AM, Richard Damon wrote:

On 3/3/25 10:07 PM, olcott wrote:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

*Proves that the input to HHH(DD) can be rejected as non-halting*

No, it proves that the HHH that rejects the input, didn't do a correct simulation, and thus was looking at the wrong input, because you don't understand what a program is.

DD only is non-halting if *THE* HHH (and there is only one at any time) never aborts. SInce HHH musts abort its emulation to "reject" the input,
it proves it didn't do the needed correct emulation, and you are shown
to be just a blantant liar.

And the HHH that correctly emulated DD, can't be a decider and answer.

Also. "the HHH", defined in your Halt7.c doesn't do that,

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

Failing to provide the above proves that you are clueless
about this code.

Nope, I have shown why your logic is wrong,

If that was true you could show this with
something besides rhetoric and double-talk.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20c-Linux NewsLink 1.2

From Newsgroup: comp.lang.c++

Op 04.mrt.2025 om 16:52 schreef olcott:

On 3/4/2025 8:43 AM, Muttley@DastardlyHQ.org wrote:

On Tue, 4 Mar 2025 08:21:39 -0600
olcott <polcott333@gmail.com> wibbled:

On 3/4/2025 4:06 AM, Bonita Montero wrote:

Am 04.03.2025 um 04:07 schrieb olcott:

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.

You're wrong; your program will never stop - like
your halting problem investigations.

I am not wrong and no one can show that I wrong

You're making the assertion, so YOU need to prove the program will halt,
its not for others to prove that it won't.

The code proves that DD correctly emulated by HHH
cannot possibly reach its own "ret" instruction and
terminate normally. This proves that HHH(DD) is correct
to reject its input as non-terminating.

No, it reports its failure to do a correct simulation.

If this is incorrect then someone could point out exactly
how DD correctly emulated by HHH would reach its own "ret"
instruction.

If HHH did not fail to reach the 'ret' instruction Olcott could show a
trace that reaches the 'ret' instruction.
--- Synchronet 3.20c-Linux NewsLink 1.2