<EgoBot> GOOD: , works
<EgoBot> GOOD: : duplicates
<EgoBot> GOOD: empty stack pops zero
<EgoBot> GOOD: 2-2 = 0
<EgoBot> GOOD: | works
<EgoBot> GOOD: 0! = 1
<EgoBot> GOOD: 7! = 0
<EgoBot> GOOD: 8*0 = 0
<EgoBot> GOOD: # < jumps into <
<EgoBot> GOOD: swaps
<EgoBot> GOOD: 01` = 0
<EgoBot> GOOD: 10` = 1
<EgoBot> GOOD: 900pg gets 9
<EgoBot> GOOD: p modifies space
<EgoBot> Befunge-98 detected.
<EgoBot> GOOD: wraparound works
<EgoBot> GOOD: a pushes 10
<EgoBot> GOOD: b-f push 11-15
<EgoBot> GOOD: [ turns left
<EgoBot> GOOD: ] turns right
<EgoBot> GOOD: instructions between ; are skipped
<EgoBot> UNDEF: # across left edge hits easternmost cell in file
<EgoBot> UNDEF: # across left edge hits easternmost cell on line
<EgoBot> GOOD: 0k^ doesn't execute ^
<EgoBot> GOOD: 1k[ turns left from k
<EgoBot> GOOD: 4k # jumps 4 times from k
<EgoBot> GOOD: 2k ;;;5 executes 5 thrice
<EgoBot> GOOD: 2k# jumps twice from k
<EgoBot> GOOD: ak47k$ leaves 3 fours on stack
<EgoBot> GOOD: 2k6 leaves 3 sixes on stack
<EgoBot> GOOD: putting to and getting (-1 -1) worked, assuming working negative Funge-Space
<EgoBot> GOOD: 9 / 2 = 4
<EgoBot> GOOD: 9 % 2 = 1
<EgoBot> About to test division by zero...
<EgoBot> GOOD: 1 / 0 = 0
<EgoBot> GOOD: 1 % 0 = 0
<EgoBot> GOOD: SGML spaces
<EgoBot> GOOD: n clears 15-cell stack: assuming it works
<EgoBot> GOOD: r reflects
<EgoBot> GOOD: 21w turns right
<EgoBot> GOOD: ' pushes 20
<EgoBot> GOOD: 'vs^ goes through
<EgoBot> GOOD: 'vs places v
<EgoBot> GOOD: z doesn't reflect
<EgoBot> GOOD: 3j jumps over 3 cells
<EgoBot> GOOD: 04-j jumps backward the right number of cells
<EgoBot> GOOD: 1j ^ jumps into ^
<EgoBot> GOOD: 10x goes east
<EgoBot> GOOD: 1-1x goes southwest
<EgoBot> GOOD: 32x sets delta to (3, 2)
<EgoBot> Assuming we can trust x...
<EgoBot> GOOD: wraparound with non-cardinal delta appears to work
<EgoBot> GOOD: { transfers cells correctly
<EgoBot> GOOD: { sets storage offset correctly, and p uses it
<EgoBot> GOOD: } resets storage offset
<EgoBot> GOOD: } transfers cells correctly
<EgoBot> GOOD: { with negative argument works
<EgoBot> GOOD: } with negative argument works
<EgoBot> GOOD: } reflects when stack stack has only one stack
<EgoBot> GOOD: u reflects when stack stack has only one stack
<EgoBot> GOOD: u with zero count does nothing
<EgoBot> GOOD: u with a positive count transfers cells correctly
<EgoBot> GOOD: u with a negative count transfers cells correctly
<EgoBot> y claims all of the following:
<EgoBot> That t is implemented
<EgoBot> That buffered I/O is being used
<EgoBot> That the number of bytes per cell is 4
<EgoBot> That the interpreter's handprint is 1128682830
<EgoBot> That the interpreter's version is 40
<EgoBot> That the behaviour of = is unavailable
<EgoBot> That the system's path separator is /
<EgoBot> That this Funge has 2 dimensions
<EgoBot> That the ID of the current IP is 0
<EgoBot> That the team number of the current IP is 0
<EgoBot> That the position of the IP was ( 64 89 )
<EgoBot> That the delta of the IP was ( -1 0 )
<EgoBot> That the offset of the IP was ( 0 0 )
<EgoBot> That the least point containing a non-space cell is ( -1 -1 )
<EgoBot> That the greatest point, relative to that point, is ( 180 795 )
<EgoBot> That the day of the month is 1
<EgoBot> That the month is 5
<EgoBot> That the year is 2009
<EgoBot> That the time is 00 : 08 : 44
<EgoBot> That the size of the stack stack is 1
<EgoBot> That the stack sizes are [ 0 ] from top to bottom
<EgoBot> That the command-line arguments were: [ "/tmp/input.23753" ]
<EgoBot> That the environment variables are:
<EgoBot> HOME=/home/egobot
<EgoBot> PWD=/home/egobot/egobot/multibot_cmds
<EgoBot> PATH=/usr/local/bin:/usr/bin:/bin:/usr/games
<EgoBot> USER=egobot
<EgoBot> SHELL=/bin/bash
<EgoBot> TERM=screen
<EgoBot> Best that the above claims are manually verified to be correct.
<EgoBot> GOOD: 1y works
<EgoBot> GOOD: 5y works
<EgoBot> GOOD: dy works
<EgoBot> GOOD: 1y and 5y do not disagree about =
<EgoBot> No reliable cross-platform method of testing: assume = works
<EgoBot> UNDEF: i not implemented according to 1y - cannot test it
<EgoBot> UNDEF: can't test o without working i, may overwrite some existing file
<EgoBot> 1y says this is Concurrent Funge-98
<EgoBot> Going to test concurrent execution with 2 IPs.
* EgoBot has quit (Excess Flood)
<EgoBot> A line (consider it UNDEF, though not marked as such) will be emitted for each fingerprint tested for, whether or not the interpreter supports it.
<EgoBot> If the interpreter loads the fingerprint, subsequent lines will be GOOD or BAD depending on whether the interpreter behaves according to the fingerprint's specification.
<EgoBot> Fingerprints will be unloaded after being tested. If ) does not work, it will fail silently.
<EgoBot> Testing fingerprint NULL... loaded.
<EgoBot> GOOD: all of A-Z reflected
<EgoBot> Testing fingerprint HRTI... loaded.
<EgoBot> UNDEF: G gives clock granularity as 2 microseconds
<EgoBot> GOOD: T reflected when called before M
<EgoBot> UNDEF: S pushed 880044
<EgoBot> UNDEF: T after M pushed 3 and a second T, after 675 ys, pushed 1845
<EgoBot> GOOD: ET reflected
<EgoBot> Testing fingerprint MODE... not loaded.
<EgoBot> Testing fingerprint MODU... loaded.
<EgoBot> GOOD: a04-M pushes -2
<EgoBot> Assuming that "C-language integer remainder" refers to C99 C, it used to be undefined...
<EgoBot> GOOD: a04-R pushes 2
<EgoBot> GOOD: 0a-04-R pushes -2
<EgoBot> GOOD: 0a-04-U pushes 2
<EgoBot> Testing fingerprint ORTH... loaded.
<EgoBot> GOOD: 56A pushes 4
<EgoBot> GOOD: 56E pushes 3
<EgoBot> GOOD: 56O pushes 7
<EgoBot> GOOD: G works
<EgoBot> GOOD: P works
<EgoBot> GOOD: Cannot test S reliably. If this line begins with "GOOD: ", it worked.
<EgoBot> GOOD: X seems to work
<EgoBot> GOOD: Y seems to work
<EgoBot> GOOD: V changes dx correctly
<EgoBot> GOOD: W changes dy correctly
<EgoBot> GOOD: 0Z ramps
<EgoBot> GOOD: 1Z doesn't ramp
<EgoBot> Testing fingerprint PERL... not loaded.
<EgoBot> Testing fingerprint REFC... loaded.
<EgoBot> UNDEF: 12R34R56R pushed the scalars [ 1 2 3 ]
<EgoBot> GOOD: D returned first vector
<EgoBot> GOOD: D returned second vector
<EgoBot> GOOD: D returned third vector
<EgoBot> GOOD: D returned first vector the second time
<EgoBot> Testing fingerprint ROMA... loaded.
<EgoBot> GOOD: I pushes 1
<EgoBot> GOOD: V pushes 5
<EgoBot> GOOD: X pushes 10
<EgoBot> GOOD: L pushes 50
<EgoBot> GOOD: C pushes 100
<EgoBot> GOOD: D pushes 500
<EgoBot> GOOD: M pushes 1000
<EgoBot> Testing fingerprint TOYS... loaded.
<EgoBot> GOOD: A works
<EgoBot> UNDEF: 12B leaves stack as [ -1 3 ] (from top to bottom)
<EgoBot> GOOD: 3DDD is zero
<EgoBot> GOOD: IIDD is zero
<EgoBot> GOOD: 123456789abcdefE is 120
<EgoBot> GOOD: 112345P is 120
<EgoBot> GOOD: 882*1-N is -127
<EgoBot> GOOD: 64H is 96
<EgoBot> GOOD: b7*03-H is 9
<EgoBot> UNDEF: 0f-03-H is -2, meaning H did a signed right shift
<EgoBot> GOOD: C works as a basic copy
<EgoBot> GOOD: K works as a basic copy
<EgoBot> GOOD: M works as a basic move
<EgoBot> GOOD: V works as a basic move
<EgoBot> GOOD: overlapping copy with C works
<EgoBot> GOOD: overlapping copy with K works
<EgoBot> GOOD: overlapping move with M works
<EgoBot> GOOD: overlapping move with V works
<EgoBot> GOOD: S works
<EgoBot> UNDEF: F pops j after i
<EgoBot> GOOD: F works
<EgoBot> GOOD: G works
<EgoBot> GOOD: 1J moves itself south one row
<EgoBot> GOOD: 01-J moves itself north one row
<EgoBot> GOOD: 01-O moves its row one column to the west
<EgoBot> GOOD: 1O moves its row one column to the east
<EgoBot> GOOD: L gets left-hand space
<EgoBot> GOOD: L gets left-hand normal cell
<EgoBot> GOOD: R gets right-hand space
<EgoBot> GOOD: R gets right-hand normal cell
<EgoBot> GOOD: Q works
<EgoBot> GOOD: 00T goes right
<EgoBot> GOOD: 01T goes down
<EgoBot> UNDEF: 02T reflects
<EgoBot> GOOD: U transmuted into all of ><^v
<EgoBot> GOOD: 000p000W goes through
<EgoBot> GOOD: 000p100W waits indefinitely
<EgoBot> GOOD: 000p01-00W reflects
<EgoBot> GOOD: X works
<EgoBot> GOOD: Y works
<EgoBot> UNDEF: Z in Befunge reflects
<EgoBot> Testing fingerprint TURT... not loaded.
<EgoBot> Testing fingerprint BASE... loaded.
<EgoBot> UNDEF: B outputs 40 as 101000
<EgoBot> UNDEF: H outputs 40 as 28
<EgoBot> UNDEF: O outputs 40 as 50
<EgoBot> UNDEF: N outputs 40 in base 0 as nothing: it reflected
<EgoBot> UNDEF: N outputs 40 in base 1 as 0000000000000000000000000000000000000000
<EgoBot> UNDEF: N outputs 40 in base 2 as 101000
<EgoBot> UNDEF: N outputs 40 in base 3 as 1111
<EgoBot> UNDEF: N outputs 40 in base 4 as 220
<EgoBot> UNDEF: N outputs 40 in base 5 as 130
* EgoBot has quit (Excess Flood)
<EgoBot> UNDEF: N outputs 40 in base 40 as nothing: it reflected
<EgoBot> Testing fingerprint CPLI... loaded.
<EgoBot> GOOD: ( 1+2i) + (3+4i) is ( 4+6i) according to A
<EgoBot> GOOD: ( 3+4i) - (2+ i) is ( 1+3i) according to S
<EgoBot> GOOD: ( 1+2i) * (3+4i) is (10-5i) according to M
<EgoBot> GOOD: (88-4i) / (9+4i) is ( 8-4i) according to D
<EgoBot> GOOD: 34V is 5
<EgoBot> UNDEF: abO outputs 10+11i
<EgoBot> UNDEF: 0a-bO outputs -10+11i
<EgoBot> UNDEF: a0b-O outputs 10-11i
<EgoBot> UNDEF: 0a-0b-O outputs -10-11i
<EgoBot> Testing fingerprint DATE... loaded.
<EgoBot> GOOD: C pushed [2131,08,31] given 2500000
<EgoBot> GOOD: C pushed [-9999,04,01] given -1930544
<EgoBot> GOOD: J pushes 98645 given [-4444,12,24]
<EgoBot> GOOD: J reflects given [0,0,0]
<EgoBot> GOOD: J pushes 990634 given [-2001,2,29]
<EgoBot> GOOD: J pushes -1119007 given [-7777,2,29]
<EgoBot> GOOD: A claims 2008-04-01 minus 32 days is 2008-02-29
<EgoBot> GOOD: D claims the number of days from 2008-04-01 to 2008-02-29 is -32
<EgoBot> GOOD: T claims the 366th day of 2008 is 2008-12-31
<EgoBot> GOOD: T reflects given day 400 of 2008
<EgoBot> GOOD: W claims 2008-08-14 was a Thursday
<EgoBot> GOOD: Y claims 2008-08-14 was the 227th day of the year
<EgoBot> GOOD: Y reflects given [0,1,1]
<EgoBot> GOOD: Y reflects given [1,0,1]
<EgoBot> GOOD: Y reflects given [1,1,0]
<EgoBot> GOOD: Y reflects given [2008,15,1]
<EgoBot> GOOD: Y reflects given [2008,1,32]
<EgoBot> Testing fingerprint DIRF... not loaded.
<EgoBot> Testing fingerprint EVAR... not loaded.
<EgoBot> Testing fingerprint FILE... not loaded.
<EgoBot> Testing fingerprint FIXP... loaded.
<EgoBot> GOOD: b6A is 2
<EgoBot> GOOD: 93O is 11
<EgoBot> GOOD: c6X is 10
<EgoBot> GOOD: C says cos(35) is 0.8192 or 0.8191
<EgoBot> GOOD: I says sin(35) is 0.5736 or 0.5735
<EgoBot> GOOD: T says tan(35) is 0.7002
<EgoBot> GOOD: B says acos(1) is 0
<EgoBot> GOOD: B says acos(0) is 90
<EgoBot> GOOD: B says acos(-1) is 180
<EgoBot> GOOD: J says asin(0.3) is 17.4576
<EgoBot> UNDEF: 2aaaa****J pushes -2147483648
<EgoBot> GOOD: U says atan(2348.2368) is 89.9756
<EgoBot> UNDEF: called 3D 9 times and got [ 2 1 0 2 2 2 0 2 2 ]
<EgoBot> GOOD: 01-N is 1
<EgoBot> GOOD: 0S is 0
<EgoBot> GOOD: 2S is 1
<EgoBot> GOOD: 03-S is -1
<EgoBot> GOOD: 5V is 05-V
<EgoBot> GOOD: P says 16777216 * pi is 52707178 or 52707179
<EgoBot> GOOD: Q says sqrt(200) is 14
<EgoBot> GOOD: 23R is 8
<EgoBot> GOOD: 203-R is 0
<EgoBot> GOOD: 02-3R is -8
<EgoBot> GOOD: 02-03-R is 0
<EgoBot> GOOD: 02R is 0
<EgoBot> UNDEF: 002-R pushes -2147483648
<EgoBot> GOOD: 20R is 1
<EgoBot> GOOD: 02-0R is 1
<EgoBot> UNDEF: 00R pushes 1
<EgoBot> Testing fingerprint FPSP... loaded.
<EgoBot> Because floating point equality is, with epsilons, too tricky, and without them, poorly defined, and because rounding with I is too inaccurate, results of calculations will be UNDEF. The precisely correct answer will follow, to 6 decimal places: the calculated result can be compared to it.
<EgoBot> UNDEF: cFP outputs 12.000000
<EgoBot> UNDEF: 0"1234.567890"R results in 1234.567871
<EgoBot> GOOD: 8FI is 8
<EgoBot> UNDEF: aFeFA results in 24.000000 (24)
<EgoBot> UNDEF: cF7FS results in 5.000000 (5)
<EgoBot> UNDEF: 6FaFM results in 60.000000 (60)
* EgoBot has quit (Excess Flood)
<EgoBot> UNDEF: ASMDF say 355/113 is 3.141593 (3.141593)
<EgoBot> UNDEF: D says 1/0 is inf (NaN or +infinity)
<EgoBot> UNDEF: D says -1/0 is -inf (NaN or -infinity)
<EgoBot> UNDEF: B says sin(4.2) is -0.871576 (-0.871576)
<EgoBot> UNDEF: C says cos(42) is -0.399985 (-0.399985)
<EgoBot> UNDEF: T says tan(-.42) is -0.446573 (-0.446573)
<EgoBot> UNDEF: E says asin(2) is nan (actually complex: NaN)
<EgoBot> UNDEF: H says acos(0) is 1.570796 (1.570796)
<EgoBot> UNDEF: G says atan(100) is 1.560797 (1.560797)
<EgoBot> UNDEF: K says ln(0) is -inf (-infinity)
<EgoBot> UNDEF: K says ln(1) is 0.000000 (0)
<EgoBot> UNDEF: K says ln(2) is 0.693147 (0.693147)
<EgoBot> UNDEF: L says log10(20) is 1.301030 (1.301030)
<EgoBot> UNDEF: X says exp(3) is 20.085537 (20.085537)
<EgoBot> UNDEF: N says -0 is -0.000000 (-0)
<EgoBot> UNDEF: V says abs(-15) is 15.000000 (15)
<EgoBot> UNDEF: Q says sqrt(8) is 2.828427 (2.828427)
<EgoBot> UNDEF: Y says pow(-8, 9) is -134217728.000000 (-134217728)
<EgoBot> UNDEF: Y says pow(2, -7) is 0.007812 (0.007813)
<EgoBot> Testing fingerprint FRTH... loaded.
<EgoBot> GOOD: D after n is 0
<EgoBot> GOOD: y and D agree that stack size after y is 184
<EgoBot> GOOD: L rolls value correctly
<EgoBot> GOOD: P picks value correctly
<EgoBot> GOOD: O overs value correctly
<EgoBot> GOOD: R rots value correctly
<EgoBot> Testing fingerprint IIPC... not loaded.
<EgoBot> Testing fingerprint IMAP... not loaded.
<EgoBot> Testing fingerprint INDV... loaded.
<EgoBot> GOOD: G works
<EgoBot> GOOD: P works
<EgoBot> GOOD: V uses logical order
<EgoBot> GOOD: W works
<EgoBot> Testing fingerprint SOCK... not loaded.
<EgoBot> Testing fingerprint STRN... loaded.
<EgoBot> GOOD: A works
<EgoBot> GOOD: C claims "foo" is greater than "Foo"
<EgoBot> GOOD: C claims "Bar" is less than "bar"
<EgoBot> GOOD: C claims "qUx" is equal to itself
<EgoBot> GOOD: F finds correctly
<EgoBot> GOOD: F pushes 0 on mismatch
<EgoBot> GOOD: Cannot test D reliably. If this line begins with "GOOD: ", it worked.
<EgoBot> GOOD: G works
<EgoBot> GOOD: P works
<EgoBot> GOOD: "zaB"2L is "Ba"
<EgoBot> UNDEF: 00L reflects
<EgoBot> UNDEF: "ooF"01-L reflects
<EgoBot> GOOD: "zaB"2R is "az"
<EgoBot> UNDEF: 00R leaves 0 on stack
<EgoBot> UNDEF: "ooF"01-R reflects
<EgoBot> GOOD: "zaBraBooF"34M is "BarB"
<EgoBot> UNDEF: 000M leaves 0 on stack
<EgoBot> UNDEF: "ooF"101-M reflects
<EgoBot> UNDEF: "ooF"01-1M reflects
<EgoBot> UNDEF: "ooF"42M reflects
<EgoBot> UNDEF: "ooF"24M reflects
<EgoBot> GOOD: 0N is 0
<EgoBot> GOOD: "foo"N is 3
<EgoBot> GOOD: "0987654321"VS is 1234567890
<EgoBot> Testing fingerprint SUBR... loaded.
<EgoBot> GOOD: J worked
<EgoBot> GOOD: set mode with O
<EgoBot> GOOD: J worked
<EgoBot> GOOD: C worked
<EgoBot> GOOD: C transfers stack elements correctly
<EgoBot> GOOD: R worked
<EgoBot> GOOD: R transfers stack elements correctly
<EgoBot> GOOD: set mode with A
<EgoBot> GOOD: C worked
<EgoBot> GOOD: C transfers stack elements correctly
<EgoBot> GOOD: R worked
<EgoBot> GOOD: R transfers stack elements correctly
<EgoBot> Testing fingerprint TIME... loaded.
<EgoBot> UNDEF: YODHMS claim that the local time is (or was a few moments ago) 2009 - 5 - 1 00 : 08 : 44
<EgoBot> UNDEF: YODHMS claim that the GMT time is (or was a few moments ago) 2009 - 5 - 1 00 : 08 : 44
<EgoBot> GOOD: L seems to work
<EgoBot> UNDEF: F claims that it is the 120 day of the year
<EgoBot> UNDEF: W claims that it is the 6 day of the week, starting from sunday
<EgoBot> Testing fingerprint JSTR... loaded.
<EgoBot> GOOD: P works
<EgoBot> GOOD: G works
<EgoBot> About to test detailed () behaviour with two fingerprints.
<EgoBot> MODU and ROMA were chosen for their simplicity (for implementers) and partially overlapping instruction set.
<EgoBot> Loaded ROMA, then MODU.
<EgoBot> GOOD: M has MODU semantics
<EgoBot> GOOD: CDILRUVX doesn't reflect
<EgoBot> Unloaded ROMA.
<EgoBot> GOOD: M has ROMA semantics
<EgoBot> GOOD: RU doesn't reflect
<EgoBot> GOOD: all of CDILVX reflected
<EgoBot> Unloaded MODU.
<EgoBot> GOOD: R and U reflected
<EgoBot> About to test, using ROMA, whether t copies the parent IP's loaded fingerprint semantics to the child IP.
<EgoBot> This is unmentioned in the specification, and thus is UNDEF.
<EgoBot> Loaded ROMA.
<EgoBot> Forked into child IP.
<EgoBot> UNDEF: IVXLCDM didn't reflect: child IP has ROMA loaded
<EgoBot> The Mycology Befunge-98 test suite is practically done.
<EgoBot> Trying to quit with q. If the return status is 15, consider it GOOD...