Ching-Tang Tseng
Hamilton, New
Zealand
1 May 2017
ilikeforth@gmail.com
http://forthfortnight.blogspot.com
Some kinds of output format are hard to implement out by a traditional BASIC.
A few codes are hard to read out clearly in traditional FORTH coding style.
I improved.
A few such kinds of example are showing in this article.
ABC FORTH special features are emphasized here on
purpose.
Example 1 : Output ability
First day I touched FORTH, I knew FORTH output ability
is better than any other kinds of non-extendable language, especial compare to
a traditional BASIC. No matter it is just to do a general printing output or is
to do a complicated port output to a device, FORTH certainly is the best tool
to do it.
Here is a simple question (courtesy of
http://practicalcomputing.org/tips/rosetta) needs a program to print out a
table, all elements inside are a regular order character attached by a regular
order number as the following format.
Table.1
A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12
B1 B2 B3 B4 B5 B6 B7 B8 B9 B10 B11 B12
C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 C12
D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12
E1 E2 E3 E4 E5 E6 E7 E8 E9 E10 E11 E12
F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12
G1 G2 G3 G4 G5 G6 G7 G8 G9 G10 G11 G12
H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12
Traditional BASIC has a PRINT instruction for printing
message out. Variable names, 『 "....." 』, 『 , 』, 『 ; 』, or a mathematical expression
are able to be used to follow a PRINT instruction. After PRINT, system must to
do a line feed and carriage return once. Such a PRINT specification cannot help
us to print out Table.1 except you are using an artificial echo printing method.
In a general FOTH system, arrange an ASCII code EMIT and
an index . (DOT) together such as
"j emit i ." to be wrapped in
double structure of DO ... LOOP as following can performed out this table,
ForthTable and BasicTable are the answer codes.
ForthTable and BasicTable are the answer codes.
: ForthTable ( -- )
cr
73 65
do
13 1
do
j emit i
.
loop
cr
loop ;
In ABC FORTH, use a powerful RUN instruction to do
"j emit i .". Let you get the same effective output result. Traditional
BASIC lack of such a feature.
2 integers i j
: BasicTable ( -- )
basic
10 run cr
20 for j = 65 to 72
30 for i = 1 to 12
40 run j emit i .
50 next i
60 run cr
70 next j
80 end ;
Execution result:
ForthTable
A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12
B1 B2 B3 B4 B5 B6 B7 B8 B9 B10 B11 B12
C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 C12
D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12
E1 E2 E3 E4 E5 E6 E7 E8 E9 E10 E11 E12
F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12
G1 G2 G3 G4 G5 G6 G7 G8 G9 G10 G11 G12
H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12
ok
BasicTable
A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12
B1 B2 B3 B4 B5 B6 B7 B8 B9 B10 B11 B12
C1 C2 C3 C4 C5 C6 C7 C8 C9 C10 C11 C12
D1 D2 D3 D4 D5 D6 D7 D8 D9 D10 D11 D12
E1 E2 E3 E4 E5 E6 E7 E8 E9 E10 E11 E12
F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12
G1 G2 G3 G4 G5 G6 G7 G8 G9 G10 G11 G12
H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12
ok
Example 2. Chinese Remainder Theorem
One example of these questions is showing in the
program. Please see the contents of logical branch condition in Line 20.
\ simple version
integer i
: simple ( -- )
basic
10 for i = 1 to 100000000000
20 if ( i mod
11 = 1 ) and ( i mod 13 = 2 )
and ( i mod
15 = 3 ) and ( i mod 17 = 4 )
and ( i mod
19 = 5 )
then 60
30 next i
40 print " Question is inexact! "
50 goto 80
60 run 2drop
70 print " Answer = N * " ; i ; " , N =
1, 2, 3, ... "
80 end ;
\ turbo version: How does it speeded up? You ought to
know.
: turbo ( -- )
basic
10 for i = 19 + 5 to 100000000000 step 19
20 if ( i mod
11 = 1 ) and ( i mod 13 = 2 )
and ( i mod
15 = 3 ) and ( i mod 17 = 4 )
and ( i mod
19 = 5 )
then 60
30 next i
40 print " Question is inexact! "
50 goto 80
60 run 2drop
70 print " Answer = N * " ; i ; " , N =
1, 2, 3, ... "
80 end ;
simple
turbo
Answer = N * 346413 , N = 1, 2, 3, ...
Answer = N * 346413 , N = 1, 2, 3, ... OK
You are able to solve all kinds of Chinese Remainder
Theorem problem with the same code listed above by just to replace the contents in
line 20.
Upper limit index of FOR...NEXT set to be such a big number
is on purpose for testing in 64 bits system.
If ABC FORTH is not built in a general FORTH system, we
are unable to deal with the code in Line 60 RUN 2DROP. Is this ability to be
called unstructured?
Example 3. 64 bits working range
ABC FORTH is very easy to follow up a new or a 64 bits
FORTH system.
At the beginning of 64 bits era, a public domain 64 bits
BASIC is not so easy coming out quickly.
For me, so long as there is a FORTH system existed already,
I may have ABC FORTH added to it in less than 2 weeks. Even though a 64 bits
new FORTH system is always lack of floating point functions, I am able to build
my personal pure software floating point functions in it by ABC FORTH itself.
I don't like to work on any kinds of vendor's FORTH. I
used to work on public domain FORTH only.
Apply a 64 bits ABC FORTH program to find prime numbers
over a fixed 64 bits range can show you some special features.
These programs are simply based on the following three
properties of Prime Numbers.
(1) The lowest even prime number is 2
(2) The lowest odd prime number is 3
(3) All prime numbers above 3 can be represented by the
formula 6n + 1 and 6n - 1 for n>=1
This was the simplest version adopted by me at the beginning
when I developed.
5 integers I J L A B
: SimplePrange ( -- )
BASIC
10 print " Input start and stop numbers A and B, A
< B, A must >= 10 " cr
20 inputi A , B
30 for J = A to B
40 if ( J mod 2 = 0 ) OR ( J mod 3 = 0 ) then 220
50 for I = 6 to sqrt ( J ) + 1 step 6
60 if ( J mod ( I - 1 ) = 0 ) OR ( J mod ( I + 1 ) = 0 )
then 210
70 next I
100 print J
110 goto 220
210 run 2drop
220 next J
300 end ;
The final consolidated TurboPrange code with proving output
is as following.
You are able to get some detail features via to compare
it to the SimplePrange code listed above.
5 integers I J A B C
: TurboPrange ( -- )
BASIC
10 print " Enter start and stop numbers A and B, A
< B, A must >= 10 " cr
20 inputi A , B
30 LET C = 0
40 for J = A to B
50 if J mod 2 = 0 then 220
60 if J mod 3 = 0 then 220
70 for I = 6 to sqrt ( J ) + 1 step 6
80 if J mod ( I - 1 ) = 0 then 210
90 if J mod ( I + 1 ) = 0 then 210
100 next I
110 let C = C + 1
120 print J ; " = 6 x " ; J / 6 ; " +
" ; J mod 6
130 goto 220
210 run 2drop
220 next J
310 PRINT " Total primes = " ; C
320 end ;
TurboPrange
Enter start and stop numbers A and B, A < B, A must
>= 10 !
? 1000000000001000 1000000000002000
1000000000001003 = 6 x 166666666666833 + 5
1000000000001027 = 6 x 166666666666837 + 5
1000000000001063 = 6 x 166666666666843 + 5
1000000000001089 = 6 x 166666666666848 + 1
1000000000001117 = 6 x 166666666666852 + 5
1000000000001209 = 6 x 166666666666868 + 1
1000000000001269
= 6 x 166666666666878 + 1
1000000000001293 = 6 x 166666666666882 + 1
1000000000001347 = 6 x 166666666666891 + 1
1000000000001371 = 6 x 166666666666895 + 1
1000000000001413 = 6 x 166666666666902 + 1
1000000000001491 = 6 x 166666666666915 + 1
1000000000001503 = 6 x 166666666666917 + 1
1000000000001551 = 6 x 166666666666925 + 1
1000000000001617 = 6 x 166666666666936 + 1
1000000000001623 = 6 x 166666666666937 + 1
1000000000001669 = 6 x 166666666666944 + 5
1000000000001741 = 6 x 166666666666956 + 5
1000000000001749 = 6 x 166666666666958 + 1
1000000000001819 = 6 x 166666666666969 + 5
1000000000001839 = 6 x 166666666666973 + 1
1000000000001867 = 6 x 166666666666977 + 5
1000000000001897
= 6 x 166666666666982 + 5
Total primes = 23
OK
Example 4: Self-built programming grammar
Courtesy of http://rosettacode.org/wiki/100_doors, I would like to cite contents in this website to test my ABC FORTH by means of some different codes.
This program is a nice tool to find a prime number in a
specified range. I developed it and applied it to many aspects. Program is
posting here only to prevent anybody argue any doubted tips to me. Simplification is to be emphasized first. No more simplification are needed. If a number is not a
prime number, it will be checked out by MOD operation with four numbers: 2, 3,
6n-1, 6n+1. Speed is acceptable. There are no storage table must to be announced
in this program.
When I am doing congruence method random number
generator design, I need a so called magic number in 64 bits environment, it
should be a prime number. This program help me some.
There are many websites consumed a lot of storage capacity
to show you all prime numbers among a specified range. I need not to waste my
time for surfing. 14 lines code are enough to satisfy my demand.
Before I got the output outcome, I was still doubted a
little bit about all prime numbers could be represented by 6n-1 or 6n+1 format.
I used this program to prove it. Example 4: Self-built programming grammar
Courtesy of http://rosettacode.org/wiki/100_doors, I would like to cite contents in this website to test my ABC FORTH by means of some different codes.
For the purpose of convenience, 100 Doors question re-post
here again:
Question:
There are 100 doors in a row that are all initially
closed.
You make 100 passes by the doors.
The first time through, visit every door and toggle
the door (if the door is
closed, open it; if it is open, close it).
The second time, only visit every 2nd door (door #2, #4, #6, ...), and toggle it.
The third time, visit every 3rd door (door #3, #6, #9, ...), etc, until you only visit the 100th door.
Task:
Answer the question:
what state are the doors in after the last pass? Which are open, which are closed?
The alternate solution in that web page has been ignored here,
owing to have no interesting.
Somebody did a FORTH version. Thanks to him. Instruction
"toggle" is still an useful word to me. So quote it first.
: toggle ( c-addr -- ) \ toggle the byte at c-addr
dup c@ 1 xor
swap c! ;
100 1+ ( 1-based
indexing ) constant ndoors
create doors
ndoors allot
: finit ( -- )
doors ndoors erase ; \ close
all doors
: pass ( n -- ) \ toggle every nth
door
ndoors over do
doors i +
toggle
dup ( n )
+loop drop ;
: run ( -- )
ndoors 1 do i pass loop ;
: display ( -- )
\ display open
doors
ndoors 1
do doors i + c@ if i .
then loop cr ;
: DoorsV1 CR finit run display ;
A few ABC FORTH codes can do the same thing out. All
of them are using the same one array data structure DOOR(100). FORTH system
used to do nothing about initialization for a data structure. Instruction "binit"
is doing it.
DoorsV2 is a directive translated code from its original
GW-BASIC demonstrated code.
100 (ARRAY) DOOR
2 integers HOP I
: binit ( -- )
basic
10 FOR I = 1 TO 100
20 LET DOOR ( I ) = 0
30 NEXT I
40 end ;
: DoorsV2 ( -- )
BASIC
10 run binit
40 FOR HOP = 1 TO 100
50 FOR I = 0 TO 100 STEP HOP
60 LET DOOR ( I ) = DOOR ( I ) + 1
70 NEXT I
80 NEXT HOP
90 FOR I = 1 TO 100
100 IF DOOR ( I ) MOD 2 = 1 THEN 120
110 GOTO 130
120 PRINT I
130 NEXT I
140 END ;
The following 3 codes use this common code named
PrintResult.
: PrintResult
BASIC
10 FOR I = 1 TO 100
20 IF door ( I ) = 1 then 40
30 goto 50
40 PRINT " Door " ; I ; " is open "
50 NEXT I
60 END ;
DoorsV3 line 40 is showing one kind of self-built
programming grammar. Phrase "address-of door ( I ) iarray" can give
you the address of one array element Door(I). Original FORTH "toggle"
word can help you to toggle its content.
: DoorsV3
basic
10 run binit
20 FOR hop = 1 TO 100
30 FOR I = hop TO 100 STEP hop
40 run address-of door ( I ) iarray toggle
50 NEXT I
60 NEXT hop
70 RUN PrintResult
80 end ;
DoorsV4 line 40 is showing another kind of self-built
programming grammar. All contents of Door(I) toggled by means of mathematical
calculation: original content plus 1 then MOD 2.
: DoorsV4
basic
10 run binit
20 FOR hop = 1 TO 100
30 FOR I = hop TO 100 STEP hop
40 LET DOOR ( I ) = ( DOOR ( I ) + 1 ) MOD 2
50 NEXT I
60 NEXT hop
70 RUN PrintResult
80 end ;
DoorsV5 line 40 is showing one more kind of self-built
programming grammar. DoorsV5 adopt a functionalized method to solve this
problem. Let ABC FORTH can do the same thing as what the other BASICs can do.
Beware! Here this BASIC function "NOT" is not
the same as FORTH word "NOT". We must defined a FORTH word "0/1" first, then convert it to our new "NOT" function in BASIC
environment.
: 0/1 ( n -- 1/0 )
NOT ABS ;
' 0/1 IDEF NOT
: DoorsV5
basic
10 run binit
20 FOR hop = 1 TO 100
30 FOR I = hop TO 100 STEP hop
40 LET DOOR ( I ) = NOT ( DOOR ( I ) )
50 NEXT I
60 NEXT hop
70 RUN PrintResult
80 end ;
Execution results:
CR .( DoorsV1: )
DoorsV1
CR .( DoorsV2: )
DoorsV2
CR .( DoorsV3: )
DoorsV3
CR .( DoorsV4: )
DoorsV4
CR .( DoorsV5: )
DoorsV5
DoorsV1:
1 4 9 16 25 36 49 64 81 100
DoorsV2:
1
4
9
16
25
36
49
64
81
100
DoorsV3:
Door 1 is open
Door 4 is open
Door 9 is open
Door 16 is open
Door 25 is open
Door 36 is open
Door 49 is open
Door 64 is open
Door 81 is open
Door 100 is open
DoorsV4:
Door 1 is open
Door 4 is open
Door 9 is open
Door 16 is open
Door 25 is open
Door 36 is open
Door 49 is open
Door 64 is open
Door 81 is open
Door 100 is open
DoorsV5:
Door 1 is open
Door 4 is open
Door 9 is open
Door 16 is open
Door 25 is open
Door 36 is open
Door 49 is open
Door 64 is open
Door 81 is open
Door 100 is open
ok
Example 5: One step forward feature
During the past 30 years, a lot of people in FORTH
communities had ever done many programs to deal with the fraction number
computation. All those programs were working well under a simple fraction number format
condition. For example, to implement 1/2 + 1/3, let you get 5/6.
As for a real application, main role should be the mixed
fraction number format. Simple fraction number format could not cover all
computational requirements. Mixed fraction number are expressed such as 1(1/2)
or 3(11/17)...etc. But we must beware of their expressed meaning, an 1(1/2),
means 1 AND 1 over 2 ( 1+(1/2) ), not means 1 TIMES 1 over 2 ( 1*(1/2) ).
Based on all public domain FORTH fraction number codes,
we should stepped one more step forward, let it can be applied to our real world
application, and let it can be used in the program.
How to do it?
How to do it?
Nobody did it before, so I have to design such a system
by myself. to make up all mixed fraction number computational functions. I
dealt with all elements in the mixed fraction number system implemented the
same things as a general integer number did according to my personal
mathematical knowledge.
In this mixed fraction number system, you must consider
some new regulation. The most fundamental element expression format is
different from any other kind of mathematical system. We need 3 cells to
express an element. Its unit element is ( 1 0 1 ) or ( 0 1 1 ), Its zero
element should be ( 0 0 1). Then all other elements could follow these
regulation to define out. As to its reverse(negative) element, system allows
you to use one minus mark in one and only one cell, no matter which one of its
three cells is.
Fraction mathematic is an absolute value system. We
don't have to consider its precision. System has its own independent 4
mathematical operations /+/, /-/, /*/, ///. All general functions, for example
/MAX/, /MIN/, /**/, /SGN/, /ABS/...etc, could be designed out.
A sounded mixed fraction number system must able to be
used in the program. The following demo program show you this feature. I added one special output word mn. at the end. It converts a mixed fraction number to a
setting digits after the decimal point number. Digits setting is adjustable, here we set 1008 digits to it.
Question:
What are the summation and the average value of this
mixed fraction number series.
1&(1/1) + 2&(1/2) + ..........+ 10&(1/10)
Traditional FORTH code in the ABC FORTH system could be
coded as following:
/variable/ sumF
: demo1
0 0 1 sumF /!/
11 1
do
sumF /@/ i 1 i
/+/ sumF /!/
loop
cr ."
sumF = " sumF /@/ /3./
sumf /@/ 10 0 1
///
cr ."
sumF/10 = " /3./
cr sumF /@/ mn.
;
The following BASIC format code in ABC FORTH are doing
the same thing as above:
integer i
fraction sumB
: demo2
BASIC
10 let /{ sumB = ( 0 0 1 ) }/
20 for i = 1 to 10
30 let /{ sumB = sumB + ( i 1 i ) }/
40 next i
50 run cr ." sumB
= " address-of sumB /@/ /3./
60 let /{ sumB = sumB / ( 10 0 1 ) }/
70 run cr ." sumB/10 = " address-of sumB /@/
/3./
80 run cr address-of sumB /@/ mn.
90 end
;
PAGE DEMO1 DEMO2
\s
sumF = 57 &
( 2341 / 2520 )
sumF/10 = 5 & ( 19981 / 25200 )
57.92896825396825396825396825396825396825396825396 :50
82539682539682539682539682539682539682539682539682 :100
53968253968253968253968253968253968253968253968253 :150
96825396825396825396825396825396825396825396825396 :200
82539682539682539682539682539682539682539682539682 :250
53968253968253968253968253968253968253968253968253 :300
96825396825396825396825396825396825396825396825396 :350
82539682539682539682539682539682539682539682539682 :400
53968253968253968253968253968253968253968253968253 :450
96825396825396825396825396825396825396825396825396 :500
82539682539682539682539682539682539682539682539682 :550
53968253968253968253968253968253968253968253968253 :600
96825396825396825396825396825396825396825396825396 :650
82539682539682539682539682539682539682539682539682 :700
53968253968253968253968253968253968253968253968253 :750
96825396825396825396825396825396825396825396825396 :800
82539682539682539682539682539682539682539682539682 :850
53968253968253968253968253968253968253968253968253 :900
96825396825396825396825396825396825396825396825396 :950
82539682539682539682539682539682539682539682539682 :1000
5396825396
sumB = 57 &
( 2341 / 2520 )
sumB/10 = 5 & ( 19981 / 25200 )
5.792896825396825396825396825396825396825396825396 :50
82539682539682539682539682539682539682539682539682 :100
53968253968253968253968253968253968253968253968253 :150
96825396825396825396825396825396825396825396825396 :200
82539682539682539682539682539682539682539682539682 :250
53968253968253968253968253968253968253968253968253 :300
96825396825396825396825396825396825396825396825396 :350
82539682539682539682539682539682539682539682539682 :400
53968253968253968253968253968253968253968253968253 :450
96825396825396825396825396825396825396825396825396 :500
82539682539682539682539682539682539682539682539682 :550
53968253968253968253968253968253968253968253968253 :600
96825396825396825396825396825396825396825396825396 :650
82539682539682539682539682539682539682539682539682 :700
53968253968253968253968253968253968253968253968253 :750
96825396825396825396825396825396825396825396825396 :800
82539682539682539682539682539682539682539682539682 :850
53968253968253968253968253968253968253968253968253 :900
96825396825396825396825396825396825396825396825396 :950
82539682539682539682539682539682539682539682539682 :1000
539682539 ok
According to the extendable feature of FORTH, all kinds
of number system are able to add into the ABC FORTH. I took this feature successfully
designed out my personal using floating point number system in my 64 bits ABC
FORTH.
5 workers exposed to radiation at Japan
nuclear lab
·
By MARI YAMAGUCHI,
ASSOCIATED PRESS
TOKYO — Jun 7, 2017, 10:48 AM ET
Five workers at a Japanese nuclear
facility that handles plutonium have been exposed to high levels of radiation
after a bag containing highly radioactive material apparently broke during an
equipment inspection, the Japan Atomic Energy Agency said Wednesday.
The incident occurred Tuesday at its Oarai Research &
Development Center, a facility for nuclear fuel study that uses highly toxic
plutonium. The cause of the accident is under investigation, the state-run
agency said. It raised nuclear security concerns as well as questions about
whether the workers were adequately protected.
The agency said its initial survey found contamination inside
the nostrils of three of the five men, a sign they had inhaled radioactive
dust. All five were also found to be contaminated on their limbs after removing
protective gear and taking a shower, which would have washed off most
contamination.
Agency spokesman Masataka Tanimoto said one of the men had high
levels of plutonium exposure in his lungs. The worker, in his 50s, had opened
the lid of the container when some of the 300 grams (10 ounces) of plutonium
and uranium in the broken bag flew out.
Internal exposure poses a bigger concern because of potential
cancer-causing risks. The man's exposure, 22,000 Becquerels, could mean the
effect on his lungs may not be immediately life-threatening but would add up
over time, and he will need to be regularly monitored, said Makoto Akashi, a
doctor at the National Institute of Radiological Sciences, where the workers
are being treated.
Nuclear Regulation Authority Chairman Shunichi Tanaka blamed
work routine complacency as a possible cause. Regulators have started
investigating possible violations of safety standards at the facility.
JAEA has a poor safety record at Monju, a plutonium-burning fast
breeder reactor that it oversees. The government recently decided to scrap
Monju, which suffered a major accident in 1995 and has since hardly operated.
Japan's possession of large plutonium stockpiles, from the
country's struggling nuclear spent-fuel recycling program, has faced
international criticism. Critics say Japan should stop extracting plutonium,
which could be used to develop nuclear weapons.
To reduce the stockpile, Japan plans
to burn plutonium in the form of MOX fuel — a mixture of plutonium and uranium
— in conventional reactors. But the restarting of halted nuclear plants has
proceeded slowly amid persistent anti-nuclear sentiment since the 2011
Fukushima nuclear reactor meltdown caused by a massive earthquake and tsunami.
http://abcnews.go.com/Technology/wireStory/workers-exposed-radiation-japan-nuke-lab-47880726
這篇美國ABC 新聞的報導，向全世界公告日本一直在從事於惡毒的鈽提取研究，目標是造原子彈。
三天前，20170607星期三，東京附近的日本Oarai
鈽燃料研發中心發生重大意外。
五名外行人在沒有防護設施的情況下，打開一個隨便只使用兩層塑料袋，裝運300公克的鈽鈾混裝桶，結果造成可怕的鈽內曝露重大事故，日本一直在亂搞鈽提煉之事便傳揚開來。
日本提煉乏燃料中鈽的研究，主要就是要取得原子彈原料鈽239，但一直騙世人說是要發展鈽鈾混合燃料的快中子原子爐。
福島熔毀的原子爐，就是日本硬在已使用35年的老舊原子爐中，強裝鈽鈾燃料丸所造成的。這個重大事故令日本終止此項發展一段時日，現在又故態復萌，惡劣之至。
1995年，這個機構也曾發生處理鈽時超臨界意外事故，當場死了好幾個人，那是形同一枚爛原子彈當場爆炸的核子事故，快中子原子爐的計畫也被叫停好幾年。現在，又開始亂搞了。
美國軍國主義思想意圖扶植日本軍國主義侵略中國，才允許日本這樣亂搞。現在國際原子能總署的頭頭，就是美國安排的一個日本人魁儡，專門配合美國人辦事。
這個名叫IAEA的機構，經常欺騙全世界，胡扯有關核子方面的訊息，伊拉克戰爭莫須有的理由，就由IAEA發出。
這個IAEA也是當初強迫台灣毀掉所有和平用途研究用原子爐的美國打手，我是直接當事人，熟知一切。
再度見到美、日亂整的訊息，令人氣憤，因此，我不惜浪費時間為文眾告世人。
日本必須關閉所有的鈽提取設施與研究。
發電廠用過的乏燃料內沒有適合造原子彈的鈽，主因就是內含轉化過度的鈽242，此物只吃中子，不貢獻分裂滋生反應所需的條件。若非如此，台電所有的乏燃料都能拿來煉出原子彈。日本明知不該為而硬為，原因無它，就是想搞原子彈。
全世界必須制止日本人繼續亂來，否則就該聯合起來滅掉整個日本的人種，才能永絕後患，才能為全世界帶來真正的和平。
***************************************************************
薄弱的百姓，眼含悲慘深沉的無奈，背負一個痴肥撈錢卻高喊病態正義的政權。
丹麥雕塑家 Jens Galschiot 感性雕塑，充份代表了台灣人民今日的處境。
"An obese, morbid justice, being carried by a miserable, thin people, with deep eyes."
Sensational sculpture by Danish Jens Galschiot.
It is fully described the situation of today's Taiwanese.
***************************************************************
薄弱的百姓，眼含悲慘深沉的無奈，背負一個痴肥撈錢卻高喊病態正義的政權。
丹麥雕塑家 Jens Galschiot 感性雕塑，充份代表了台灣人民今日的處境。
"An obese, morbid justice, being carried by a miserable, thin people, with deep eyes."
Sensational sculpture by Danish Jens Galschiot.
It is fully described the situation of today's Taiwanese.
