m"eʂ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe-Inferred1Possible ways the input string can be malformed. 9Is the given string a valid number with no other tokens? 3Tries to read a word, giving an error if it fails.  Safe-Inferred *Each F18A instruction, ordered by opcode. )0The 18-bit word type used by Greenarrays chips. *<The names of the different instructions, ordered by opcode. +All of the opcodes, in order. ,BTries to read a given string as an opcode from the list of names. -1Converts a word to an opcode. The word has to be < 32. .6Converts an Opcode to its 18-bit word representation. /AReturns whether the given opcode is a jump instruction expecting  an address. 0*Can the given opcode go in the last slot? 1?Estimates how long a given opcode will take to execute. Normal E opcodes take 1.5 nanoseconds where ones that access the memory take  5 nanoseconds. ,  !"#$%&'()*+,-./01*  !"#$%&'()*+,-./01*)('&%$#"!  *+,-./01  ('&%$#"!  )*+,-./01None2'A program in the F18A instruction set. 3:Represents a word in memory. This word can either contain @ opcodes, opcodes and a jump address or just a constant number. 9@Splits a list into chunks of at most four, breaking off a chunk C whenever it sees an element matching the given predicate. This is B useful for splitting a program along word boundaries, accounting  for jump addresses. :<Read a whole program, splitting instructions up into words. ;?Returns the given instructions as an actual word. This assumes % the address is sized appropriately. <%Reads in a word as a set of opcodes. =>Returns the opcodes in the given instruction word. A constant ( corresponds to not having any opcodes. >BEstimates the running time of the program in nanoseconds. This is B based on the numbers provided in the manual: faster instructions E take 1.5 nanoseconds and slower ones take 5. For now, this estimate * ignores control flow like ifs and loops. 23456789:;<=> 23456789:;<=> 38765429:;<=> 23876549:;<=>None@A stack containing only 0s. AKPushes the given element on top of the stack, discarding the last element. BBPops the top of the stack, returning the value and the new stack. C3Push the given elements onto the stack one-by-one. ?@ABC?@ABC@ABC??@ABCNone DAA state representing the registers, stacks and memory of a core. PThe chip's RAM and ROM RAThe state corresponding to a core with no programs loaded and no  instructions executed. S=The next word of instructions to execute in the given state. T:Pops the data stack of the given state, updating s and t. U3Push a word onto the data stack, updating s and t. V6Pops the return stack of the given state, updating r. W/Push a word onto the return stack, updating r. X3Force an address to be in range of memory: [0,64). Y5Read the memory at a location given by a Forth word. Z"Set the memory using Forth words. [:Loads the given program into memory at the given starting  position. DEFGHIJKLMNOPQRSTUVWXYZ[DEFGHIJKLMNOPQRSTUVWXYZ[PQDEFGHIJKLMNORSTUVWXYZ[D EFGHIJKLMNOPQRSTUVWXYZ[None \Runs a single word'7s worth of instructions starting from the given state. ]?Executes a single instruction in the given state, incrementing  the program counter. ^Returns a trace of the program'!s execution. The trace is a list + of the state of the chip after each step. _:Trace a program until it either hits four nops or all 0s. `?Runs the program unil it hits a terminal state, returning only  the resulting state. aBExecutes the specified program on the given state until it hits a  terminal. word--a word made up of four nops or all 0s. b1Estimates the execution time of a program trace. c=Checks that the program trace terminated in at most n steps,  returning Nothing otherwise. d@Does the given opcode cause the current word to stop executing? e'Executes an opcode on the given state. f1Execute a jump instruction to the given address. \]^_`abcdef \]^_`abcdef \]^_`abcdef \]^_`abcdefNone g4A program to be manipulated by the MCMC synthesizer h1Represents a single instruction as viewed by the B synthesizer. This can be an opcode, a numeric literal or a token  representing an unused slot. q=Tries to parse the given string as an instruction, which can " either be a number, an opcode or _ representing Unused. r"Reads a program in the synthesizer' s format. t-Does this instruction force a word boundary? u?Resolves labels into addresses, assuming the program starts at  the given memory location. vBInsert extra nops to account for instructions that cannot go into  the last slot. wAGets a synthesizer program from a native program. Currently does  not support jumps. x6Runs a given program from the default starting state. y<Loads the given synthesizer-friendly program into the given  state. ghijklmnopqrstuvwxyghijklmnopqrstuvwxynpohmlkjigqrstuvwxyghmlkjinpoqrstuvwxyNonez&A function that computes a measure of distance between two @ states. The larger the returned number, the more different the  states. {;Counts the number of bits that differ between two numbers. |BReturn a distance function that counts the different bits between , the given registers. You could use it like `compareRegisters [s, t]`. };Returns a distance function that counts the different bits % between the given memory locations. ~=Combines multiple distance functions to create a new one, by " summing the different distances. z{|}~z{|}~z{|}~z{|}~ NoneBGiven a specification program and some inputs, evaluate a program A against the specification for both performance and correctness. =The default distribution of instructions. For now, we do not @ support any sort of jumps. All the other possible instructions : along with constant numbers and unused slots are equally ? likely. The numeric value of constants is currently a uniform ! distribution over 18-bit words. BThe default mutations to try. For now, this will either change an A instruction or swap two instructions in the program, with equal  probability.      !"#$%&'()*+,-./0123456789:;<=>?@A=BCDEFGHIJKLMMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ H array-forth-0.2.0.5Language.ArrayForth.ParseLanguage.ArrayForth.Opcode!Language.ArrayForth.NativeProgramLanguage.ArrayForth.StackLanguage.ArrayForth.StateLanguage.ArrayForth.InterpreterLanguage.ArrayForth.ProgramLanguage.ArrayForth.DistanceLanguage.ArrayForth.Synthesis ParseError BadNumberNoAddrNotJumpNotSlot3 BadOpcodeisNumberreadWordOpcodeSetASetBPushNopReadAOverPopDupDropOrAndPlusNotDiv2Times2 MultiplyStepStoreStoreB StorePlusStorePFetchFetchB FetchPlusFetchPMinusIfIfNextUnextCallJmpExecRetF18Wordnamesopcodes readOpcodetoOpcode fromOpcodeisJumpslot3 opcodeTime NativeProgramInstrsConstantJump1Jump2Jump3 splitWordsreadNativeProgramtoBitsfromBits toOpcodes runningTimeStackemptypushpopfillStateabiprst dataStack returnStackmemoryMemoryemptyMem startStatenextdpopdpushrpoprpushtoMem!set setProgramwordstep traceProgram stepProgramevalrunNativeProgram countTimethrottleendWordexecutejumpProgram InstructionUnusedLabelNumberJumpAddrAbstractConcretereadInstruction readProgramtoNativeboundarylabelsfixSlot3 fromNative runProgramloadDistance countBits registers locations distancesevaluate defaultOpsdefaultMutations$fShowParseError $fReadOpcode $fShowOpcode $fIsString[]$fRead[] $fShowInstrs $fShowStack $fShowState$fShowInstruction $fShowAddr$fRandomOddWord