On 8/17/2024 7:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
Simulating Termination Analyzer H is Not Fooled by Pathological Input D
https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:31 AM, olcott wrote:
On 8/17/2024 7:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
Simulating Termination Analyzer H is Not Fooled by Pathological Input D
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
And here you admit to your scam.
You call HHH an "emulator" in describeing DDD, but it is a termination
Analyzer when it is ruhn.
You keep trying to get away with changing the subject
from the exact words written above.
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:31 AM, olcott wrote:
On 8/17/2024 7:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
Simulating Termination Analyzer H is Not Fooled by Pathological Input D
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
And here you admit to your scam.
You call HHH an "emulator" in describeing DDD, but it is a termination
Analyzer when it is ruhn.
I am not going to go around and around with you on this.
Every reply that diverges from the exact words written
to the tiniest extent will be construed as deception.
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be correctly
emulated by the semantics of the x86 language is just a LIAR.
You are inserting a word that I did not say.
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be correctly
emulated by the semantics of the x86 language is just a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to
validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be
correctly emulated by the semantics of the x86 language is just a
LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to
validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
How do you emulate dthe CALL HHH instruction without the code that
follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
On 8/17/2024 11:16 AM, Richard Damon wrote:
On 8/17/24 11:35 AM, olcott wrote:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be
correctly emulated by the semantics of the x86 language is just >>>>>>>> a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible
to validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
How do you emulate dthe CALL HHH instruction without the code that
follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
And thus, ALL of memory is the "input" and thus any change in it
renders that answer possibly different.
There are no other words that can be added to my
words that change the immutable fact of my words.
On 8/17/2024 12:36 PM, Richard Damon wrote:
On 8/17/24 1:24 PM, olcott wrote:
On 8/17/2024 11:16 AM, Richard Damon wrote:
On 8/17/24 11:35 AM, olcott wrote:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>> *running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be
correctly emulated by the semantics of the x86 language is >>>>>>>>>> just a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be
possible to validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
How do you emulate dthe CALL HHH instruction without the code that >>>>>> follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
And thus, ALL of memory is the "input" and thus any change in it
renders that answer possibly different.
There are no other words that can be added to my
words that change the immutable fact of my words.
Which are just meaningless garbage and a LIE.
The DDD given can not be "emulated" by HHH,
*just meaningless garbage and a LIE*
On 8/17/2024 12:48 PM, Richard Damon wrote:
On 8/17/24 1:42 PM, olcott wrote:
On 8/17/2024 12:36 PM, Richard Damon wrote:
On 8/17/24 1:24 PM, olcott wrote:
On 8/17/2024 11:16 AM, Richard Damon wrote:
On 8/17/24 11:35 AM, olcott wrote:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>>>> *running unless aborted* (out of memory error excluded) >>>>>>>>>>>>>
No, anyone saying that the above is something that CAN be >>>>>>>>>>>> correctly emulated by the semantics of the x86 language is >>>>>>>>>>>> just a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be
possible to validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible. >>>>>>>>>
How do you emulate dthe CALL HHH instruction without the code
that follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
And thus, ALL of memory is the "input" and thus any change in it
renders that answer possibly different.
There are no other words that can be added to my
words that change the immutable fact of my words.
Which are just meaningless garbage and a LIE.
The DDD given can not be "emulated" by HHH,
*just meaningless garbage and a LIE*
So, what IS the correct emulation of a program that goes off into
undefined memory?
Do I have to repeat this 500 times before you notice
that I said it once?
Utterly baseless false assumption that is directly
contradicted by the verified fact that x86utm takes
Halt7.obj as its input data, thus having all of the
machine code of HHH directly available to DDD.
Do I have to repeat this 500 times before you notice
that I said it once?
Utterly baseless false assumption that is directly
contradicted by the verified fact that x86utm takes
Halt7.obj as its input data, thus having all of the
machine code of HHH directly available to DDD.
Do I have to repeat this 500 times before you notice
that I said it once?
Utterly baseless false assumption that is directly
contradicted by the verified fact that x86utm takes
Halt7.obj as its input data, thus having all of the
machine code of HHH directly available to DDD.
Do I have to repeat this 500 times before you notice
that I said it once?
Utterly baseless false assumption that is directly
contradicted by the verified fact that x86utm takes
Halt7.obj as its input data, thus having all of the
machine code of HHH directly available to DDD.
Do I have to repeat this 500 times before you notice
that I said it once?
Utterly baseless false assumption that is directly
contradicted by the verified fact that x86utm takes
Halt7.obj as its input data, thus having all of the
machine code of HHH directly available to DDD.
On 8/17/2024 1:28 PM, Richard Damon wrote:
On 8/17/24 2:11 PM, olcott wrote:
On 8/17/2024 12:48 PM, Richard Damon wrote:
On 8/17/24 1:42 PM, olcott wrote:
On 8/17/2024 12:36 PM, Richard Damon wrote:
On 8/17/24 1:24 PM, olcott wrote:
On 8/17/2024 11:16 AM, Richard Damon wrote:
On 8/17/24 11:35 AM, olcott wrote:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>>>>>> *running unless aborted* (out of memory error excluded) >>>>>>>>>>>>>>>
No, anyone saying that the above is something that CAN be >>>>>>>>>>>>>> correctly emulated by the semantics of the x86 language is >>>>>>>>>>>>>> just a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be >>>>>>>>>>>> possible to validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible. >>>>>>>>>>>
How do you emulate dthe CALL HHH instruction without the code >>>>>>>>>> that follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
And thus, ALL of memory is the "input" and thus any change in it >>>>>>>> renders that answer possibly different.
There are no other words that can be added to my
words that change the immutable fact of my words.
Which are just meaningless garbage and a LIE.
The DDD given can not be "emulated" by HHH,
*just meaningless garbage and a LIE*
So, what IS the correct emulation of a program that goes off into
undefined memory?
Do I have to repeat this 500 times before you notice
that I said it once?
Utterly baseless false assumption that is directly
contradicted by the verified fact that x86utm takes
Halt7.obj as its input data, thus having all of the
machine code of HHH directly available to DDD.
But x86utm isn't HHH.
x86utm doesn't take "DDD" as its input, but the COFF file that
contains the whole problem.
Thus DDD has direct access to HHH in this shared memory space.
On 8/17/2024 1:50 PM, Richard Damon wrote:
On 8/17/24 2:39 PM, olcott wrote:
On 8/17/2024 7:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
Thus DDD has direct access to HHH in this shared memory space.
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my claim.
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM, RichardDamon wrote:
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my claim.
Suure it does.
Since your argument tries to say that since DDD is the same to all of
them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have*
*If I made a mistake then show that*
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
*Everything that is not expressly stated below is*
*specified as unspecified*
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
On 8/17/2024 3:20 PM, Richard Damon wrote:
On 8/17/24 4:10 PM, olcott wrote:
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM, RichardDamon wrote:
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my claim.
Suure it does.
Since your argument tries to say that since DDD is the same to all
of them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have*
*If I made a mistake then show that*
I did.
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
*Everything that is not expressly stated below is*
*specified as unspecified*
Ok.
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, DDD can NOT be emulated accoreding to the semantics of the x86
langauge, because the contents of the location 000015d2 is not
provided to be emulated, and will need to be emulated after emulating
the call instruction.
Everything that is logically entailed by the above specification
is included by reference. The assumption that DDD and HHH were
not in the same memory space has always been ridiculous.
On 8/17/2024 4:00 PM, Richard Damon wrote:
On 8/17/24 4:41 PM, olcott wrote:
On 8/17/2024 3:20 PM, Richard Damon wrote:
On 8/17/24 4:10 PM, olcott wrote:
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM,Richard Damon wrote:
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my claim.
Suure it does.
Since your argument tries to say that since DDD is the same to all >>>>>> of them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have*
*If I made a mistake then show that*
I did.
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
*Everything that is not expressly stated below is*
*specified as unspecified*
Ok.
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, DDD can NOT be emulated accoreding to the semantics of the x86
langauge, because the contents of the location 000015d2 is not
provided to be emulated, and will need to be emulated after
emulating the call instruction.
Everything that is logically entailed by the above specification
is included by reference. The assumption that DDD and HHH were
not in the same memory space has always been ridiculous.
Then I guess you accept that every different HHH generates a DIFFERENT
Input, as that input, BY LOGHICAL NECESSITY includes all the code of
HHH so it can be emulated, and thus you claims that "All the DDDs have
the same bytes" is just a blantent lie.
This is my only claim
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
I am not claiming anything about any bytes.
On 8/17/2024 4:11 PM, Richard Damon wrote:
On 8/17/24 5:05 PM, olcott wrote:
On 8/17/2024 4:00 PM, Richard Damon wrote:
On 8/17/24 4:41 PM, olcott wrote:
On 8/17/2024 3:20 PM, Richard Damon wrote:
On 8/17/24 4:10 PM, olcott wrote:
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM,Richard Damon wrote:
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my claim. >>>>>>>>>
Suure it does.
Since your argument tries to say that since DDD is the same to >>>>>>>> all of them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have*
*If I made a mistake then show that*
I did.
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
*Everything that is not expressly stated below is*
*specified as unspecified*
Ok.
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, DDD can NOT be emulated accoreding to the semantics of the x86 >>>>>> langauge, because the contents of the location 000015d2 is not
provided to be emulated, and will need to be emulated after
emulating the call instruction.
Everything that is logically entailed by the above specification
is included by reference. The assumption that DDD and HHH were
not in the same memory space has always been ridiculous.
Then I guess you accept that every different HHH generates a
DIFFERENT Input, as that input, BY LOGHICAL NECESSITY includes all
the code of HHH so it can be emulated, and thus you claims that "All
the DDDs have the same bytes" is just a blantent lie.
This is my only claim
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
I am not claiming anything about any bytes.
And, as I point out, that isn't true if HHH ever aborts its simulation.
That is merely agreeing with what I said
X = DDD emulated by HHH according to the semantics of the x86 language
Y = HHH never aborts its emulation of DDD
Z = DDD never stops running
I said: (X ∧ Y) ↔ Z
You said ~Y which entails ~Z just like I said.
I had to rewrite that a bunch of times.
On 8/17/2024 5:09 PM, Richard Damon wrote:
On 8/17/24 5:43 PM, olcott wrote:
On 8/17/2024 4:11 PM, Richard Damon wrote:
On 8/17/24 5:05 PM, olcott wrote:
On 8/17/2024 4:00 PM, Richard Damon wrote:
On 8/17/24 4:41 PM, olcott wrote:
On 8/17/2024 3:20 PM, Richard Damon wrote:
On 8/17/24 4:10 PM, olcott wrote:
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM, >>>>>>>>> Richard Damon wrote:
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my claim. >>>>>>>>>>>
Suure it does.
Since your argument tries to say that since DDD is the same to >>>>>>>>>> all of them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have* >>>>>>>>> *If I made a mistake then show that*
I did.
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
*Everything that is not expressly stated below is*
*specified as unspecified*
Ok.
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, DDD can NOT be emulated accoreding to the semantics of the >>>>>>>> x86 langauge, because the contents of the location 000015d2 is >>>>>>>> not provided to be emulated, and will need to be emulated after >>>>>>>> emulating the call instruction.
Everything that is logically entailed by the above specification >>>>>>> is included by reference. The assumption that DDD and HHH were
not in the same memory space has always been ridiculous.
Then I guess you accept that every different HHH generates a
DIFFERENT Input, as that input, BY LOGHICAL NECESSITY includes all >>>>>> the code of HHH so it can be emulated, and thus you claims that
"All the DDDs have the same bytes" is just a blantent lie.
This is my only claim
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
I am not claiming anything about any bytes.
And, as I point out, that isn't true if HHH ever aborts its simulation. >>>>
That is merely agreeing with what I said
X = DDD emulated by HHH according to the semantics of the x86 language
Y = HHH never aborts its emulation of DDD
Z = DDD never stops running
I said: (X ∧ Y) ↔ Z
You said ~Y which entails ~Z just like I said.
I had to rewrite that a bunch of times.
But, that also means that you have agreed that this only hold is HHH
doesn't EVER abort its emulaiton,
In the same way that
X = when you are starving hungry
Y = never eat
Z = you will die
(X ∧ Y) ↔ Z
remains true yet does not hold in the case of ~X ∨ ~Y.
You never actually refuted (X ∧ Y) ↔ Z
You simply started with ~Y.
On 8/17/2024 5:21 PM, Richard Damon wrote:
On 8/17/24 6:17 PM, olcott wrote:
On 8/17/2024 5:09 PM, Richard Damon wrote:
On 8/17/24 5:43 PM, olcott wrote:
On 8/17/2024 4:11 PM, Richard Damon wrote:
On 8/17/24 5:05 PM, olcott wrote:
On 8/17/2024 4:00 PM, Richard Damon wrote:
On 8/17/24 4:41 PM, olcott wrote:
On 8/17/2024 3:20 PM, Richard Damon wrote:
On 8/17/24 4:10 PM, olcott wrote:
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM, >>>>>>>>>>> Richard Damon wrote:
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my >>>>>>>>>>>>> claim.
Suure it does.
Since your argument tries to say that since DDD is the same >>>>>>>>>>>> to all of them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have* >>>>>>>>>>> *If I made a mistake then show that*
I did.
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
*Everything that is not expressly stated below is*
*specified as unspecified*
Ok.
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>> *running unless aborted* (out of memory error excluded)
No, DDD can NOT be emulated accoreding to the semantics of the >>>>>>>>>> x86 langauge, because the contents of the location 000015d2 is >>>>>>>>>> not provided to be emulated, and will need to be emulated
after emulating the call instruction.
Everything that is logically entailed by the above specification >>>>>>>>> is included by reference. The assumption that DDD and HHH were >>>>>>>>> not in the same memory space has always been ridiculous.
Then I guess you accept that every different HHH generates a
DIFFERENT Input, as that input, BY LOGHICAL NECESSITY includes >>>>>>>> all the code of HHH so it can be emulated, and thus you claims >>>>>>>> that "All the DDDs have the same bytes" is just a blantent lie. >>>>>>>>
This is my only claim
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
I am not claiming anything about any bytes.
And, as I point out, that isn't true if HHH ever aborts its
simulation.
That is merely agreeing with what I said
X = DDD emulated by HHH according to the semantics of the x86 language >>>>> Y = HHH never aborts its emulation of DDD
Z = DDD never stops running
I said: (X ∧ Y) ↔ Z
You said ~Y which entails ~Z just like I said.
I had to rewrite that a bunch of times.
But, that also means that you have agreed that this only hold is HHH
doesn't EVER abort its emulaiton,
In the same way that
X = when you are starving hungry
Y = never eat
Z = you will die
(X ∧ Y) ↔ Z
remains true yet does not hold in the case of ~X ∨ ~Y.
You never actually refuted (X ∧ Y) ↔ Z
You simply started with ~Y.
Strawman, and category error.
Not at all.
I claim (X ∧ Y) ↔ Z
and you provide the fake rebuttal of ~Y.
So, do you agree with my comments, or not. If not, what is ACTUALLY
wrong with them
I just told you how anyone knowing logic can see your mistake.
Failure to answer will be considered an admission that this is just
another false claim of yours that you can not support, and my
assertion is accepted by default.
On 8/17/2024 5:21 PM, Richard Damon wrote:
On 8/17/24 6:17 PM, olcott wrote:
On 8/17/2024 5:09 PM, Richard Damon wrote:
On 8/17/24 5:43 PM, olcott wrote:
On 8/17/2024 4:11 PM, Richard Damon wrote:
On 8/17/24 5:05 PM, olcott wrote:
On 8/17/2024 4:00 PM, Richard Damon wrote:
On 8/17/24 4:41 PM, olcott wrote:
On 8/17/2024 3:20 PM, Richard Damon wrote:
On 8/17/24 4:10 PM, olcott wrote:
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM, >>>>>>>>>>> Richard Damon wrote:
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my >>>>>>>>>>>>> claim.
Suure it does.
Since your argument tries to say that since DDD is the same >>>>>>>>>>>> to all of them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have* >>>>>>>>>>> *If I made a mistake then show that*
I did.
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
*Everything that is not expressly stated below is*
*specified as unspecified*
Ok.
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>> *running unless aborted* (out of memory error excluded)
No, DDD can NOT be emulated accoreding to the semantics of the >>>>>>>>>> x86 langauge, because the contents of the location 000015d2 is >>>>>>>>>> not provided to be emulated, and will need to be emulated
after emulating the call instruction.
Everything that is logically entailed by the above specification >>>>>>>>> is included by reference. The assumption that DDD and HHH were >>>>>>>>> not in the same memory space has always been ridiculous.
Then I guess you accept that every different HHH generates a
DIFFERENT Input, as that input, BY LOGHICAL NECESSITY includes >>>>>>>> all the code of HHH so it can be emulated, and thus you claims >>>>>>>> that "All the DDDs have the same bytes" is just a blantent lie. >>>>>>>>
This is my only claim
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
I am not claiming anything about any bytes.
And, as I point out, that isn't true if HHH ever aborts its
simulation.
That is merely agreeing with what I said
X = DDD emulated by HHH according to the semantics of the x86 language >>>>> Y = HHH never aborts its emulation of DDD
Z = DDD never stops running
I said: (X ∧ Y) ↔ Z
You said ~Y which entails ~Z just like I said.
I had to rewrite that a bunch of times.
But, that also means that you have agreed that this only hold is HHH
doesn't EVER abort its emulaiton,
In the same way that
X = when you are starving hungry
Y = never eat
Z = you will die
(X ∧ Y) ↔ Z
remains true yet does not hold in the case of ~X ∨ ~Y.
You never actually refuted (X ∧ Y) ↔ Z
You simply started with ~Y.
Strawman, and category error.
There aren't even any categories here:
I claim (X ∧ Y) ↔ Z
and you provide the fake rebuttal of ~Y.
*Here it is with categories*
If is raining outside and you go outside
unprotected from the rain then you will get wet.
You say it is not raining therefore I am wrong.
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:31 AM, olcott wrote:
On 8/17/2024 7:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
Simulating Termination Analyzer H is Not Fooled by Pathological Input D
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
And here you admit to your scam.
You call HHH an "emulator" in describeing DDD, but it is a termination
Analyzer when it is ruhn.
I am not going to go around and around with you on this.
Every reply that diverges from the exact words written
to the tiniest extent will be construed as deception.
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be correctly
emulated by the semantics of the x86 language is just a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to
validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be correctly >>>>>> emulated by the semantics of the x86 language is just a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to
validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
How do you emulate dthe CALL HHH instruction without the code that follows? >>
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
On 8/17/2024 1:28 PM, Richard Damon wrote:
On 8/17/24 2:11 PM, olcott wrote:
On 8/17/2024 12:48 PM, Richard Damon wrote:
On 8/17/24 1:42 PM, olcott wrote:
On 8/17/2024 12:36 PM, Richard Damon wrote:
On 8/17/24 1:24 PM, olcott wrote:
On 8/17/2024 11:16 AM, Richard Damon wrote:
On 8/17/24 11:35 AM, olcott wrote:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>>>>>> *running unless aborted* (out of memory error excluded) >>>>>>>>>>>>>>>
No, anyone saying that the above is something that CAN be correctly
emulated by the semantics of the x86 language is just a LIAR. >>>>>>>>>>>>>>
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to
validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible. >>>>>>>>>>>
How do you emulate dthe CALL HHH instruction without the code that follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
And thus, ALL of memory is the "input" and thus any change in it >>>>>>>> renders that answer possibly different.
There are no other words that can be added to my
words that change the immutable fact of my words.
Which are just meaningless garbage and a LIE.
The DDD given can not be "emulated" by HHH,
*just meaningless garbage and a LIE*
So, what IS the correct emulation of a program that goes off into
undefined memory?
Do I have to repeat this 500 times before you notice
that I said it once?
Utterly baseless false assumption that is directly
contradicted by the verified fact that x86utm takes
Halt7.obj as its input data, thus having all of the
machine code of HHH directly available to DDD.
But x86utm isn't HHH.
x86utm doesn't take "DDD" as its input, but the COFF file that contains
the whole problem.
Thus DDD has direct access to HHH in this shared memory space.
On 8/17/2024 5:21 PM, Richard Damon wrote:
On 8/17/24 6:17 PM, olcott wrote:
On 8/17/2024 5:09 PM, Richard Damon wrote:
On 8/17/24 5:43 PM, olcott wrote:
On 8/17/2024 4:11 PM, Richard Damon wrote:
On 8/17/24 5:05 PM, olcott wrote:
On 8/17/2024 4:00 PM, Richard Damon wrote:
On 8/17/24 4:41 PM, olcott wrote:
On 8/17/2024 3:20 PM, Richard Damon wrote:
On 8/17/24 4:10 PM, olcott wrote:
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM, >>>>>>>>>>> Richard Damon wrote:
And thus ALL of memory is part of the input,
Any additional details have no effect what-so-ever on my >>>>>>>>>>>>> claim.
Suure it does.
Since your argument tries to say that since DDD is the same >>>>>>>>>>>> to all of them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have* >>>>>>>>>>> *If I made a mistake then show that*
I did.
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
*Everything that is not expressly stated below is*
*specified as unspecified*
Ok.
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>> *running unless aborted* (out of memory error excluded)
No, DDD can NOT be emulated accoreding to the semantics of the >>>>>>>>>> x86 langauge, because the contents of the location 000015d2 is >>>>>>>>>> not provided to be emulated, and will need to be emulated
after emulating the call instruction.
Everything that is logically entailed by the above specification >>>>>>>>> is included by reference. The assumption that DDD and HHH were >>>>>>>>> not in the same memory space has always been ridiculous.
Then I guess you accept that every different HHH generates a
DIFFERENT Input, as that input, BY LOGHICAL NECESSITY includes >>>>>>>> all the code of HHH so it can be emulated, and thus you claims >>>>>>>> that "All the DDDs have the same bytes" is just a blantent lie. >>>>>>>>
This is my only claim
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
I am not claiming anything about any bytes.
And, as I point out, that isn't true if HHH ever aborts its
simulation.
That is merely agreeing with what I said
X = DDD emulated by HHH according to the semantics of the x86 language >>>>> Y = HHH never aborts its emulation of DDD
Z = DDD never stops running
I said: (X ∧ Y) ↔ Z
You said ~Y which entails ~Z just like I said.
I had to rewrite that a bunch of times.
But, that also means that you have agreed that this only hold is HHH
doesn't EVER abort its emulaiton,
In the same way that
X = when you are starving hungry
Y = never eat
Z = you will die
(X ∧ Y) ↔ Z
remains true yet does not hold in the case of ~X ∨ ~Y.
You never actually refuted (X ∧ Y) ↔ Z
You simply started with ~Y.
Strawman, and category error.
Trying to refute (X ∧ Y) ↔ Z
with ~Y is stupid and does not work.
On 8/18/2024 6:30 AM, Richard Damon wrote:
On 8/17/24 11:37 PM, olcott wrote:
On 8/17/2024 5:21 PM, Richard Damon wrote:
On 8/17/24 6:17 PM, olcott wrote:
On 8/17/2024 5:09 PM, Richard Damon wrote:
On 8/17/24 5:43 PM, olcott wrote:
On 8/17/2024 4:11 PM, Richard Damon wrote:
On 8/17/24 5:05 PM, olcott wrote:
On 8/17/2024 4:00 PM, Richard Damon wrote:
On 8/17/24 4:41 PM, olcott wrote:
On 8/17/2024 3:20 PM, Richard Damon wrote:
On 8/17/24 4:10 PM, olcott wrote:
On 8/17/2024 2:27 PM, Richard Damon wrote:
On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 >>>>>>>>>>>>> PM, Richard Damon wrote:
Any additional details have no effect what-so-ever on my >>>>>>>>>>>>>>> claim.And thus ALL of memory is part of the input, >>>>>>>>>>>>>>>
Suure it does.
Since your argument tries to say that since DDD is the >>>>>>>>>>>>>> same to all of them, so its the behavior.
You are just admitting to being a LIAR.
*Calling me a liar admits that insults is all that you have* >>>>>>>>>>>>> *If I made a mistake then show that*
I did.
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS >>>>>>>>>>>>>
*Everything that is not expressly stated below is*
*specified as unspecified*
Ok.
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>>>> *running unless aborted* (out of memory error excluded) >>>>>>>>>>>>>
No, DDD can NOT be emulated accoreding to the semantics of >>>>>>>>>>>> the x86 langauge, because the contents of the location >>>>>>>>>>>> 000015d2 is not provided to be emulated, and will need to be >>>>>>>>>>>> emulated after emulating the call instruction.
Everything that is logically entailed by the above specification >>>>>>>>>>> is included by reference. The assumption that DDD and HHH were >>>>>>>>>>> not in the same memory space has always been ridiculous. >>>>>>>>>>>
Then I guess you accept that every different HHH generates a >>>>>>>>>> DIFFERENT Input, as that input, BY LOGHICAL NECESSITY includes >>>>>>>>>> all the code of HHH so it can be emulated, and thus you claims >>>>>>>>>> that "All the DDDs have the same bytes" is just a blantent lie. >>>>>>>>>>
This is my only claim
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
I am not claiming anything about any bytes.
And, as I point out, that isn't true if HHH ever aborts its
simulation.
That is merely agreeing with what I said
X = DDD emulated by HHH according to the semantics of the x86
language
Y = HHH never aborts its emulation of DDD
Z = DDD never stops running
I said: (X ∧ Y) ↔ Z
You said ~Y which entails ~Z just like I said.
I had to rewrite that a bunch of times.
But, that also means that you have agreed that this only hold is
HHH doesn't EVER abort its emulaiton,
In the same way that
X = when you are starving hungry
Y = never eat
Z = you will die
(X ∧ Y) ↔ Z
remains true yet does not hold in the case of ~X ∨ ~Y.
You never actually refuted (X ∧ Y) ↔ Z
You simply started with ~Y.
Strawman, and category error.
Trying to refute (X ∧ Y) ↔ Z
with ~Y is stupid and does not work.
IU WASN'T refuting (X ∧ Y) ↔ Z
Then you are trying to get away with changing the subject
through the strawman error.
On 8/18/2024 3:58 AM, Mikko wrote:
On 2024-08-17 15:09:01 +0000, olcott said:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be
correctly emulated by the semantics of the x86 language is just a
LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to
validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
It is impossible to emulate a call if the memory content at the
called address is not kown (or even whether there is any memory
at that address). The byte sequence above contains a call to
an address that is not a part of the shown sequence.
x86utm takes the compiled Halt7.obj file of this c program https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.
On 8/18/2024 4:02 AM, Mikko wrote:
On 2024-08-17 15:35:33 +0000, olcott said:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be correctly >>>>>>>> emulated by the semantics of the x86 language is just a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to >>>>>> validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
How do you emulate dthe CALL HHH instruction without the code that follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
Now you switched the topic. Earlier you were not talking about x86utm
but emulation, both specifically of DDD by HHH and generally.
It is stupid to assume that HHH and DDD are not in the
same shared memory space.
On 8/18/2024 4:10 AM, Mikko wrote:
On 2024-08-17 18:39:47 +0000, olcott said:
On 8/17/2024 1:28 PM, Richard Damon wrote:
On 8/17/24 2:11 PM, olcott wrote:>>>>
Utterly baseless false assumption that is directly
contradicted by the verified fact that x86utm takes
Halt7.obj as its input data, thus having all of the
machine code of HHH directly available to DDD.
But x86utm isn't HHH.
x86utm doesn't take "DDD" as its input, but the COFF file that contains >>>> the whole problem.
Thus DDD has direct access to HHH in this shared memory space.
Which does meet the requirements of "emulation". In order to be
a valid emulation the memory space of the emulated system must
be simulated to the extend the emulated program acesses it.
*No: infinite loops need not be infinitely emulated*
A process similar to mathematical induction correctly
predicts when an unlimited emulation of an input
cannot possibly stop running unless aborted.
On 8/18/2024 3:58 AM, Mikko wrote:
On 2024-08-17 15:09:01 +0000, olcott said:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be correctly >>>>>> emulated by the semantics of the x86 language is just a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to
validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
It is impossible to emulate a call if the memory content at the
called address is not kown (or even whether there is any memory
at that address). The byte sequence above contains a call to
an address that is not a part of the shown sequence.
x86utm takes the compiled Halt7.obj file of this c program https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.
On 8/18/24 9:00 AM, olcott wrote:
On 8/18/2024 4:02 AM, Mikko wrote:
On 2024-08-17 15:35:33 +0000, olcott said:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>> *the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be correctly >>>>>>>>> emulated by the semantics of the x86 language is just a LIAR. >>>>>>>>>
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to >>>>>>> validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
How do you emulate dthe CALL HHH instruction without the code that follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
Now you switched the topic. Earlier you were not talking about x86utm
but emulation, both specifically of DDD by HHH and generally.
It is stupid to assume that HHH and DDD are not in the
same shared memory space.
You need to decide what can be assumed and make it clear.
Statements don't mean what you want them to mean, but what you say, and
they need to be consistant.
On 2024-08-18 13:00:19 +0000, olcott said:
On 8/18/2024 4:02 AM, Mikko wrote:
On 2024-08-17 15:35:33 +0000, olcott said:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>> *the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be
correctly emulated by the semantics of the x86 language is just >>>>>>>>> a LIAR.
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible >>>>>>> to validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
How do you emulate dthe CALL HHH instruction without the code that
follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
Now you switched the topic. Earlier you were not talking about x86utm
but emulation, both specifically of DDD by HHH and generally.
It is stupid to assume that HHH and DDD are not in the
same shared memory space.
It is stupid to assume that HHH and DDD can be in only one memory space.
On 8/19/24 3:21 AM, Mikko wrote:
On 2024-08-18 13:00:19 +0000, olcott said:
On 8/18/2024 4:02 AM, Mikko wrote:
On 2024-08-17 15:35:33 +0000, olcott said:
On 8/17/2024 10:30 AM, Richard Damon wrote:
On 8/17/24 11:09 AM, olcott wrote:
On 8/17/2024 10:06 AM, Richard Damon wrote:
On 8/17/24 10:58 AM, olcott wrote:
On 8/17/2024 9:10 AM, Richard Damon wrote:
On 8/17/24 8:29 AM, olcott wrote:
void DDD()
{
HHH(DDD);
}
_DDD()
[00002172] 55 push ebp ; housekeeping >>>>>>>>>>> [00002173] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
*It is a basic fact that DDD emulated by HHH according to* >>>>>>>>>>> *the semantics of the x86 language cannot possibly stop* >>>>>>>>>>> *running unless aborted* (out of memory error excluded)
No, anyone saying that the above is something that CAN be correctly >>>>>>>>>> emulated by the semantics of the x86 language is just a LIAR. >>>>>>>>>>
You are inserting a word that I did not say.
To say that DDD is emulated by HHH means that it must be possible to >>>>>>>> validly do that act.
You are not going to get very far with any claim that
emulating a sequence of x86 machine-code bytes is impossible.
How do you emulate dthe CALL HHH instruction without the code that follows?
Who is the silly one now?
No it has moved up to a ridiculous and utterly
baseless false assumption that is directly contradicted
by the verified fact that x86utm takes Halt7.obj as
its input data, thus having all of the machine code
of HHH directly available to DDD.
Now you switched the topic. Earlier you were not talking about x86utm
but emulation, both specifically of DDD by HHH and generally.
It is stupid to assume that HHH and DDD are not in the
same shared memory space.
It is stupid to assume that HHH and DDD can be in only one memory space.
But there is only one in *THE* memory space we are talking about.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 512 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 90:52:33 |
| Calls: | 10,018 |
| Calls today: | 1 |
| Files: | 13,849 |
| D/L today: |
1 files (9K bytes) |
| Messages: | 6,365,856 |