Si      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                    Safe-Inferred23468:M   Safe-Inferred 23468:MGA monad for accumulating string output with the possibility of failure.`Returns either the rendered result on the right, or a message describing a failure on the left.Wraps a renderer in an exception handler that, when the renderer or something it calls fails, will add context about this renderer's invocation to the failure message. Safe-Inferred23468:MA base-10, infinite-precision, floating-point number. Implemented as an infinite-precision significand together with an exponent, such that the numeric value is equal to  f * (10 ^  f)(. The exponent is a limited-precision M, because some operations may break if the exponent is larger (specifically  and +). This shouldn't be an issue for Goatee.%These values form an integral domain.The T instance always outputs in decimal notation, never scientific notation. Examples: i300 (never trailing .0 if there's no fractional part) 0.1 (never redundant trailing or leading zeros)Similarly, the . instance accepts numbers matching the regex -?\d+(\.\d+)?(e-?\d+)?R. Scientific exponent notation is supported for reading, for ease of converting s to s.encode significand exponent creates a  value whose numeric value is significand * (10 ^ exponent). Converts a  to a  (with as much precision as the   instance provides). Converts a  to a  , lossily.shift amount float adds shift zeros onto the right side of float9's numerator while keeping the numeric value the same. amount must be non-negative. Reduces a g to canonical form, keeping the numeric value the same but removing trailing zeros from the numerator. Converts two @s so that they have the same number of decimal places, so that 0 arithmetic may be performed directly on their s.Lifts a function on two s to a function on s.This is not exported from this module because it's not a general lift function: the given function only operates on the significands, so operations that require the exponent (such as multiplication) can't use this function. Safe-Inferred23468:M pDrops the element at an index from a list. If the index is out of bounds then the list is returned unmodified. Inserts the element into the list before the given position. If the position is less than 0 or greater than the length of the list, then the index is clamped to this range. listReplace old new list replaces all occurrences of old with new in list. 3Modifies the element at a specific index in a list. If any item is a , then the list of &s is returned, otherwise the list of s is returned.for is flip map..Transforms both values in a homogeneous tuple.Inverts a map, collecting all of the keys that map to a single value in one list in the result map. No guarantees are made on the order of the keys in each value's list. If you want the results in ascending order, apply   to the result.#Executes the monadic function if a  contains a value.Finds the first tuple whose first element is true, and returns its second element. If all of the first values are false, then the first argument to cond is returned instead.A function form of if that takes its test last. in a monad. Executes the actions in the list in order. If any action returns false then the remaining actions are skipped and the result is false. Otherwise all actions returned true, and the result is true. An empty list returns true./ that also passes in the index of each element.whileM test body repeatedly evaluates test% until it returns false. Every time test returns true, body is executed once.whileM' test body repeatedly evaluates test until it returns . Every time it returns a , that value is passed to body and the result is executed.doWhileM init body repeatedly calls body with init. As long as body returns a RightF value, it is re-executed with the returned value. When it returns a Left1 value, the loop stops and the value is returned.     Safe-Inferred23468:M9<The rulesets defined by the SGF specification, for use with .pA ruleset used for a Go game. Can be one of the rulesets defined by the SGF specification, or a custom string.,;The markings that SGF supports annotating coordinates with.2bA list of labels, each specified with a string and a coordinate about which to center the string.3+An undirected line between two coordinates.5#A list of lines, each specified as (startCoord, endCoord).6$A list of arrows, each specified as (startCoord, endCoord).79An enumeration that describes which variations are shown.8&Show alternatives to the current move.9"Show children of the current move.:ZSGF flags that control how move variations are to be presented while displaying the game.<%Which moves to display as variations.=+Whether to overlay variations on the board.>Stone color: black or white.A1An SGF double value: either 1 or 2, nothing else.D?An SGF real value is a decimal number of unspecified precision.EThe value type for an UnknownProperty&. Currently represented as a string.F(Returns the string contained within the UnknownProperty this value is from.GAn SGF SimpleText value.HConverts an SGF G to a string.IAn SGF text value.JConverts an SGF I to a string.KBA class for SGF data types that are coercable to and from strings.&The construction of an SGF value with M may process the input, such that the resulting stringlike value does not represent the same string as the input. In other words, the following does *not* necessarily hold: =sgfToString . stringToSgf = id (does not necessarily hold!)?The following does hold, however, for a single stringlike type: stringToSgf . sgfToString = idThe  instance is defined with sgfToString = stringToSgf = id+. For other types, the string returned by L is in a raw, user-editable format: characters that need to be escaped in serialized SGF aren't escaped, but the returned value is otherwise similar to SGF format.L,Extracts the string value from an SGF value.M)Creates an SGF value from a string value.NFA structure for compact representation of a list of coordinates. Contains a list of individual points, as well as a list of rectangles of points denoted by an ordered pair of the upper-left point and the lower-right point. The union of the single points and points contained within rectangles make up all of the points a  CoordList represents. There is no rule saying that adjacent points have to be grouped into rectangles; it's perfectly valid (although possibly inefficient) to never use rectangles.For any  CoordList, all of the following hold: ^Any point may be specified at most once, either in the singles list or in a single rectangle.For a rectangle ((x0,y0), (x1,y1)), x0 <= x1 and y0 <= y1 and (x0,y0) /= (x1,y1)3 (otherwise the point belongs in the singles list).OReturns the single points in a N.PReturns the rectangles in a N.QA coordinate on a Go board. (0, 0) refers to the upper-left corner of the board. The first component is the horizontal position; the second component is the vertical position.R7The FF versions supported by Goatee. Currently only 4.S$The default SGF version to use when FF[]! is not specified in a root node.This value is actually INCORRECT: SGF defines it to be 1, but because we don't support version 1 yet, for the sake of ignoring this issue (for now!) in tests, we fix the default to be 4.TqSGF supports multiple game types. This list contains the game types that Goatee supports, which is only Go (1).UcThe default size of the board. The FF[4] SGF spec says that the default Go board is 19x19 square.V+The minimum board size allowed by FF[4], 1.W,The maximum board size allowed by FF[4], 52.X Constructs a N containing a single point.Y Constructs a ND containing the given single points. For rectangle detection, use ].Z Constructs a N3 containing the given single points and rectangles.[A N that contains no points.\Converts a compact N to a list of coordinates.] Constructs a N from a list of Qks, doing some not-completely-stupid rectangle detection. The order of data in the result is unspecified.^starLines width height returns V a list of row/column indices that have star points on a board of the given size, or 6 if the board size does not have star points defined._isStarPoint width height x y determines whether (x, y)A is a known star point on a board of the given width and height.handicapStoneIndices !! k* the positions of the handicap stones for k handicap stones, betweeen 0 and 9. In the pairs, 0 indicates the first star point along an axis, 1 indicates the second, and 2 indicates the third, in the normal Q ordering.`$handicapStones width height handicap returns a list of points where handicap stones should be placed for the given handicap, if handicap points are defined for the given board size, otherwise .aConverts between K types via a string. -convertStringlike = stringToSgf . sgfToStringbConverts a string to an SGF I.cConverts a string to an SGF G>, replacing all whitespaces (including newlines) with spaces.dConstructs a value for a UnknownProperty.eNReturns the logical negation of a stone color, yang for yin and yin for yang.f9The default variation mode as defined by the SGF spec is 'VariationMode ShowChildVariations True.gMParses a numeric variation mode, returning nothing if the number is invalid.h/Returns the integer value for a variation mode.i Converts a 3 to a pair of Q$s representing the line's endpoints.j0Returns the string representation for a ruleset.k,Parses a string representation of a ruleset. FEquality is based on unordered, set equality of the underlying points.a !"#$%&'()*+,-./0123456789:;<=>?@ABCDE FG HI JKLMN OPQRSTUVWXYZ[\]^_`abcdefghijk S !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkXRSTUVWQNOPOPXYZ[\]^_`KLMaIJJbGHHcEFFdDACB>@?e:;<=798fgh6534i2,10/.-&+*)('!%$#" jk8 !%$#"&+*)(',10/.-23456798:;<=>@?ACBDE FG HI JKLMN OPQRSTUVWXYZ[\]^_`abcdefghijk  Safe-Inferred23468:MA wrapper around N with a  instance used for parsing. The monoid does simple concatenation of the single and rectangle lists, so it is not appropriate for  CoordList9 proper, as it doesn't do duplicate removal between two  CoordLists.|,A parser for SGF SimpleText property values.|A parser for SGF text property values. Its argument should be true if the text is inside of a composed property value, so ':', should terminate the value in addition to ']'.$lmnopqrstuvwxy z{|}~!"#lmnopqrstuvwxyz{|}~nopqrstuvwxyz{|~lm}"lmnopqrstuvwxy z{|}~!"# Safe-Inferred 23468:M4$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW'/01234789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW4$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW Safe-Inferred23468:MXYZ[\]^_`abcdefghijklmnoXZ[\]^_`abcdefghijklmnoXYZ[\]^_`abcdefghijklmnoNone 23468:MdbMetadata for a property that contains a value. Corresponds to a non-nullary data constructor of .pOThe SGF textual name for the property (also the name of the data constructor).qThe SGF property type.r"Whether the property is inherited.s2A predicate that matches predicates to which this  applies.t0Metadata about the type of the property's value.u?A function that extracts values from properties to which this R applies. It is invalid to call this function with a different type of property.v5A function that builds a property containing a value.fMetadata for a property that does not contain a value. Corresponds to a nullary data constructor of .w&The SGF textual name for the property.x$The single instance of the property.yThe SGF property type.z"Whether the property is inherited.pAn existential type for any descriptor of a property that holds a value of a specific type. Has instances for  and , similar to .2An existential type for any property descriptor.  has a W instance, so there is no need to extract the value with a pattern match before using  methods. A class for )s of properties that also contain values.xExtracts the value from a property of the given type. Behaviour is undefined if the property is not of the given type.%Builds a property from a given value.0A class for types that contain metadata about a '. The main instance of this class is  itself; s can be treated as though they have metadata directly. When referring to a property in general rather than a specific instance, use the values of  and . See also .7Returns the name of the property, as used in SGF files.?Returns the type of the property, as specified by the SGF spec.Returns whether the value of the given property is inherited from the lowest ancestor specifying the property, when the property is not set on a node itself.@Returns whether the given property has the type of a descriptor.0A parser of property values in SGF format (e.g. "[ab]"% for a property that takes a point)./A renderer property values to SGF format (e.g. B (Just (1,2)) renders to "[ab]").cA renderer for displaying property values in a UI. Displays the value in a human-readable format.5The property types that SGF uses to group properties.%May appear anywhere in the game tree.At most one on any path.May only appear in root nodes.Cannot mix with move nodes.Cannot mix with setup nodes.:An SGF property that gives a node meaning. A property is known: if its meaning is defined by the SGF specification, and unknownr otherwise. Known properties each have their own data constructors. Unknown properties are represented by the  data constructor.White territory.Black territory.Komi.Handicap stones (>=2).Set viewing region.White time left.$White moves left in byo-yomi period.$Black moves left in byo-yomi period.Black time left.Name of white team.Rank of white player.-Name of user or program who entered the game.Time limit, in seconds.Source of the game. Ruleset used. Round info.Result of the game.Name of white player.Where the game was played.Name of black player.The method used for overtime.Information about the opening. Game name.(Game comment, or background, or summary. Event name. Dates played.Copyright info.Name of black team.Rank of black player.Name of annotator.Board size, columns then rows.Variation display format.Game (must be 1 = Go).File format version. Charset for SimpleText and Text.Application info.Mark points with trianges.Mark points with squares.Mark points as selected.Mark points with Xs.Lines.Label points with text. Dim points.Mark points with circles.Arrows.Tesuji.Interesting move.Doubtful move. Bad move. Node value.Unclear position. Node name.Hotspot.Good for white.Good for black.Even position.Comment.Player to play.Assign white stones.Assign empty stones.Assign black stones.White move (nothing iff pass).Assign move number./Execute move unconditionally (even if illegal).Black move (nothing iff pass).}Internal to this module, do not use outside. Template Haskell function to declare a property that does not contain a value. '$(defProperty "KO" 'MoveProperty False)This example declares a propertyKO ::  that is a  and is not inherited.uInternal to this module, do not use outside. Template Haskell function to declare a property that contains a value. ?$(defValuedProperty "B" 'MoveProperty False 'maybeCoordPrinter)This example declares a  propertyB ::  (Maybe Q) that is a B and is not inherited. The value type is automatically inferred.ppqrstuv{wxyz%The SGF textual name of the property.The name of the ."Whether the property is inherited.|}~^pqrstuv{wxyzB|}~None 23468:M "$A list of descriptors for all known s.# Builds a / for an unknown property with the given name. 1Does not check that the name is actually unknown.$Returns a descriptor for any  , known or unknown. Because a  has a  instance, this function is not normally necessary for use outside of this module, but it can be used to throw away a value associated with a  and retain only the metadata.%Returns a descriptor for the given property name. The name does not have to be for a known property; an unknown property will use #.&BReturns a descriptor for a known property with the given name, or 2 if the name does not belong to a known property.'QDescriptors for setup properties that assign stones to the board. For use with ( and ).(Converts a descriptor in '" to the type of stone it assigns.)8Converts a type of stone assignment to a descriptor in '.*"Returns the descriptor for a mark.L      !"#$%&'()*J      !"#$%&'()*L      !"#$%&'()*None23468:M      !"#$%&'()*      !"#$%&'()* Safe-Inferred23468:M+2A string containing the name of this application, "Goatee".,%A user-presentable copyright message.-$The home page for Goatee on the web..!A list of contributors to Goatee.+,-.+,-.+,-.+,-.None23468:M/A wrapper around 2 with an  instance that considers two nodes equal iff they contain the same properties (not necessarily in the same order), and if they contain children (in the same order) whose nodes are recursively equal.This instance is not on 2 directly because it is not the only obvious sense of equality (only comparing properties would be another one), and it's also potentially expensive.2An SGF game tree node. Unlike in the SGF spec, we represent a game tree with nodes uniformly, rather than having the separation between sequences and nodes.6See /.9 An SGF collection of game trees.<*A node with no properties and no children.=Returns a fresh root 2 with 9 set to Goatee and optionally with a board size set via .>;Searches for a matching property in a node's property list.?4Searches for a matching property in a property list.@<Retrieves the value of a property in a node's property list.A5Retrieves the value of a property in a property list.B-Appends a property to a node's property list.CaddChild child parent- appends a child node to a node's child list.DaddChildAt index child parent inserts a child node into a node's child list at the given index, shifting all nodes at or after the given index to the right. If the position is less than 0 or greater than the length of the list, then the index is clamped to this range.EdeleteChildAt index nodeP deletes the child at the given index from the node. If the index is invalid, node is returned.FcReturns a list of validation errors for the current node, an empty list if no errors are detected./0123456789:;<=>?@ABCDEF/0123456789:;<=>?@ABCDEF9:;6782345/01<=>?@ABCDEF/0123456789:;<=>?@ABCDEF None23468:M;Keeps track of a cursor's node. Also records whether the node has been modified, and uses separate data constructors to force consideration of this.GqA pointer to a node in a game tree that also holds information about the current state of the game at that node.The cursor of the parent node in the tree. This is the cursor that was used to construct this cursor. For a root node, this is Nothing.(If this cursor's node is modified (with ,), then this parent cursor (if present) is notC updated to have the modified current node as a child; the public  takes care of this.HThe index of this cursor's node in its parent's child list. When the cursor's node has no parent, the value in this field is not specified.DThe game tree node about which the cursor stores information. The  keeps track of whether the current node has been modified since last visiting the cursor's parent (if it exists; if it doesn't, then the current node is never considered modified, although in this case it doesn't matter).  is the public export.I.The complete board state for the current node.XInternal data structure, only for move application code. Represents a group of stones.The possible results from .cThere is already a stone of the specified color on the target point, and overwriting is forbidden.=Playing the move would result in suicide, which is forbidden.The move was accepted; playing it resulted in the given board with a capture. The specified side gained the number of points given.OThe move was accepted; playing it resulted in the given board without capture. A structure that configures how 6 should handle moves that are normally illegal in Go.If false, suicide will cause  to return R. If true, suicide will kill the friendly group and give points to the opponent.3If false, playing on an occupied point will cause  to return  with the color of the stone occupying the point. If true, playing on an occupied point will overwrite the point (the previous stone vanishes), then capture rules are applied as normal.JUsed by Q to represent the state of a single point on the board. Records whether a stone is present, as well as annotations and visibility properties.L#Whether this point is a star point.QAn object that corresponds to a node in some game tree, and represents the state of the game at that node, including board position, player turn and captures, and also board annotations.SPThe state of individual points on the board. Stored in row-major order. Point (x, y) can be accessed via  !! y !! x (but prefer ).TWhether any of the board's Jgs are invisible. This is an optimization to make it more efficient to set the board to "all visible."UWhether any of the board's Jgs are dimmed. This is an optimization to make it more efficient to clear all dimming from the board.VWhether any of the board's J s have a , set on them. This is an optimization to make it more efficient to clear marks in the common case where there are no marks set._1Properties that are specified in game info nodes.w>Properties that are specified in the root nodes of game trees.| Builds a _ with the given w and no extra data.}9Returns whether a node contains any game info properties.~ Converts a _ into a list of 's that can be used to reconstruct the _.*Returns the width of the board, in stones.+Returns the height of the board, in stones. Creates a Q2 for an empty board of the given width and height.A J! for an empty point on the board. Returns the J for a coordinate on a board. Modifies a Q by updating the J at a single point.Maps a function over each J in a QV, returning a list-of-lists with the function's values. The function is called like fn y x coordState.!Applies a function to update the w within the _ of a Q.!Applies a function to update the _ of a Q.Given a QD for a parent node, and a child node, this function constructs the Q for the child node. Performs necessary updates to a QG between nodes in the tree. Clears marks. This is the first step of .0Applies a child node's properties to a prepared Q. This is the second step of .XSets all points on a board to be visible (if given true) or invisible (if given false)..Resets all points on a board not to be dimmed.Applies a property to a Q4. This function covers all properties that modify Q4s, including making moves, adding markup, and so on.XApplies the transformation function to all of a board's coordinates referred to by the N.Updates properties of a Qz given that the player of the given color has just made a move. Increments the move number and updates the player turn.As an argument to 0, causes illegal moves to be treated as errors.As an argument to 5, causes illegal moves to be played unconditionally.If the 3 represents a successful move, then the resulting Q% is returned, otherwise, the default Q given is returned.Places a stone of a color at a point on a board, and runs move validation and capturing logic according to the given parameters. Returns whether the move was successful, and the result if so.Capture if there is a liberty-less group of a color at a point on a board. Removes captured stones from the board and accumulates points for captured stones.Returns a list of the four coordinates that are adjacent to the given coordinate on the board, excluding coordinates that are out of bounds.NTakes a list of coordinates that comprise a group (e.g. a list returned from ) and returns the number of liberties the group has. Does no error checking to ensure that the list refers to a single or maximal group.Expands a single coordinate on a board into a list of all the coordinates connected to it by some continuous path of stones of the same color (or empty spaces).Returns whether it is legal to place a stone of the given color at a point on a board. Accepts out-of-bound coordinates and returns false.Returns whether it is legal for the current player to place a stone at a point on a board. Accepts out-of-bound coordinates and returns false.The cursor for the node above this cursor's node in the game tree. The node of the parent cursor is the parent of the cursor's node.This is Nothing% iff the cursor's node has no parent.=The game tree node about which the cursor stores information.!Returns a cursor for a root node.This is simply 4 . .gReturns the variations to display for a cursor. The returned list contains the location and color of  and  properties in variation nodes. Variation nodes are either children of the current node, or siblings of the current node, depending on the variation mode source.|GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Pwxyz{_`abcdefghijklmnopqrstuv|}~QRSTUVWXYZ[\]^JKLMNOPGHIHI;GHIJKLMNOPQ RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None 23468:MSA handler for Js. It is called with the old variation mode then the new variation mode.A handler for Hs. It is called with the old property list then the new property list.A handler for s.A navigation handler may navigate further, but beware infinite recursion. A navigation handler must end on the same node on which it started.A handler for @s. It is called with the old game info then the new game info.A handler for _s. It is called with a cursor at the child that was deleted (this cursor is now out of date).A handler for Bs. Called with the index of the child added to the current node.BAn existential type for any event in a particular Go monad. Like , the , , and " instances use events' names, via .KA type of event in a Go monad that can be handled by executing an action. go is the type of the Go monad. h is the handler type, a function that takes some arguments relating to the event and returns an action in the Go monad. The arguments to the handler are usually things that would be difficult to recover from the state of the monad alone, for example the  associated with a .The , , and " instances use events' names, via .The standard monad for .#The standard monad transformer for .The result of deleting a node.>The node couldn't be deleted, because it is on the path stack.AThe node couldn't be deleted, because an invalid index was given."The node was deleted successfully.2A monad (transformer) for navigating and mutating G-s, and remembering previous locations. See  and .The monad supports handlers for events raised during actions it takes, such as navigating through the tree and modifying nodes.Returns the current cursor. Returns the J at the given point.)Navigates up to the parent node, fires a l, then returns true. If already at the root of the tree, then none of this happens and false is returned.DNavigates down the tree to the child with the given index, fires a m, then returns true. If the requested child doesn't exist, then none of this happens and false is returned.If possible, moves to the sibling node immediately to the left of the current one. Returns whether a move was made (i.e. whether there was a left sibling). Fires s while moving.If possible, moves to the sibling node immediately to the right of the current one. Returns whether a move was made (i.e. whether there was a right sibling). Fires s while moving.-Navigates up to the root of the tree. Fires s for each step.xNavigates up the tree to the node containing game info properties, if any. Returns true if a game info node was found.YPushes the current location in the game tree onto an internal position stack, such that  is capable of navigating back to the same position, even if the game tree has been modified (though the old position must still exist in the tree to return to it).JReturns to the last position pushed onto the internal position stack via %. This action must be balanced by a .:Drops the last position pushed onto the internal stack by 7 off of the stack. This action must be balanced by a .2Returns the set of properties on the current node.<Modifies the set of properties on the current node. Fires g after modifying if the new property set is different from the old property set (order is irrelevant).CSearches for a property on the current node, returning it if found.RSearches for a valued property on the current node, returning its value if found.oSets a property on the current node, replacing an existing property with the same name, if one exists. Fires  if the property has changed.BDeletes a property from the current node, if it's set, and fires .Note that although a  is a , giving a valued Propertyr here will not cause deletion to match on the value of the property. That is, the following code will result in B, because the deletion only cares about the name of the property. Udo putProperty $ PL Black deleteProperty $ PL White getPropertyValue propertyPLgCalls the given function to modify the state of the given property (descriptor) on the current node. : represents the property not existing on the node, and a ( marks the property's presence. Fires u if the property changed. This function does not do any validation to check that the resulting tree state is valid.nCalls the given function to modify the state of the given valued property (descriptor) on the current node. : represents the property not existing on the node, and a B with the property's value marks the property's presence. Fires v if the property changed. This function does not do any validation to check that the resulting tree state is valid.8Mutates the string-valued property attached to the current node according to the given function. The input string will be empty if the current node either has the property with an empty value, or doesn't have the property. Returning an empty string removes the property from the node, if it was set. Fires  if the property changed.+Mutates the list-valued property attached to the current node according to the given function. The input list will be empty if the current node either has the property with an empty value, or doesn't have the property. Returning an empty list removes the property from the node, if it was set.Fires  if the property changed. See also . Mutates the Nd-valued property attached to the current node according to the given function. Conversion between  CoordList and [Coord] is performed automatically. The input list will be empty if the current node either has the property with an empty value, or doesn't have the property. Returning an empty list removes the property from the node, if it was set.FImportantly, this might not be specific enough for properties such as  and j where a present, empty list has different semantics from the property not being present. In that case,  is better.Fires  if the property changed.Mutates the game info for the current path, returning the new info. If the current node or one of its ancestors has game info properties, then that node is modified. Otherwise, properties are inserted on the root node.Sets the game's : via the * property on the root node, then fires a # if the variation mode has changed.?Retrieves the stone assigned in the current node to a point by , , or . The possible results are:Nothing: No stone has been assigned to the point. The point could still be in any state, e.g. from a play on the current node or some property in an ancestor node. Just Nothing*: The point has been assigned to be empty.Just (Just Color)B: The point has been assigned to have a stone of the given color.)Looks up all stones that are assigned by , , or m properties on the current node. Returns a map from each point to the stone that is assigned to the point.\Modifies the state of currently assigned stones, keeping in mind that it is invalid to mix  and  properties in a single node. This function has the behaviour of a user changing stone assignments in a UI. How this function works is:Pick a node to work with. If there is a move property on the current node and there is not already a setup property on the current node, then we'll create and modify a new child node. Otherwise, either there are no move properties on the node (so we can add setup properties at will), or there are both move and setup properties on the node (the node is already invalid), so we'll just modify the current node.If we're modifying the current node, then apply the modification function to the state of stone assignment for each coordinate. See  for the meaning of Maybe (Maybe Color)I. Modify the properties in the node as necessary to apply the result (). (NOTE:Z Currently one event is fired for each property modified; this may change in the future.)LIf we need to create a child node, then apply the modification function to P to determine if we're actually adding assignments. If the function returns a T, then we create a child node with the necessary assignment properties, insert it (), then navigate to it (). If the function returns , then  does nothing. Returns the , at a point on the current node.5Calls the given function to modify the presence of a , on the current node.]Adds a child node to the current node at the end of the current node's child list. Fires a  after the child is added.Adds a child node to the current node at the given index, shifting all existing children at and after the index to the right. The index must be in the range [0, numberOfChildren] . Fires a  after the child is added.Tries to remove the child node at the given index below the current node. Returns a status code indicating whether the deletion succeeded, or why not.5Registers a new event handler for a given event type.>Registers a new event handler for a given event type. Unlike ^, whose handler may receive arguments, the handler given here doesn't receive any arguments.4A single step along a game tree. Either up or down.9Represents a step down to the child with the given index.7Represents a step up from a child with the given index.A path stack is a record of previous places visited in a game tree. It is encoded a list of paths (steps) to each previous memorized position. The positions saved in calls to  correspond to entries in the outer list here, with the first sublist representing the last call. The sublist contains the steps in order that will trace the path back to the saved position./The internal state of a Go monad transformer. go6 is the type of Go monad or transformer (instance of GoMonad).&The current position in the game tree.The current path stack. Handlers for . Handlers for . Handlers for . Handlers for . Handlers for . Handlers for .&A simplified constructor function for .]Reverses a step, such that taking a step then it's reverse will leave you where you started.Takes a  from a G, returning a new G.Internal function. Takes a  in the Go monad and returns whether that step was successful (i.e. if there was a node to mode to). Updates the path stack accordingly.Executes a Go monad transformer on a cursor, returning in the underlying monad a tuple that contains the resulting value and the final cursor.mExecutes a Go monad transformer on a cursor, returning in the underlying monad the value in the transformer.aExecutes a Go monad transformer on a cursor, returning in the underlying monad the final cursor."Runs a Go monad on a cursor. See .?Runs a Go monad on a cursor and returns the value in the monad.9Runs a Go monad on a cursor and returns the final cursor.Takes a step up the game tree, updates the path stack according to the given function, then fires navigation and game info changed events as appropriate, finally returning true. When at the root of the tree, none of this happens and false is returned.Takes a step down the game tree, updates the path stack according to the given function, then fires navigation and game info changed events as appropriate, finally returning true. When the child index is invalid, none of this happens and false is returned.Returns the current path stack.tMaps over a path stack, updating with the given functions all steps that enter and leave the cursor's current node.Fires all of the handlers for the given event, using the given function to create a Go action from each of the handlers (normally themselves functions that create Go actions, if they're not just Go actions directly, depending on the event).GAn event corresponding to a child node being added to the current node.NAn event corresponding to the deletion of one of the current node's children.An event that is fired when the current game info changes, either by navigating past a node with game info properties, or by modifying the current game info properties.MAn event that is fired when a single step up or down in a game tree is made.UAn event corresponding to a modification to the properties list of the current node.1An event corresponding to a change in the active :'. This can happen when modifying the ] property, and also when navigating between collections (as they have different root nodes).ovWhen no node with game info is found, then if false, return to the original node, otherwise finish at the root node.DF7"  None23468:MIParses a string in SGF format. Returns an error string if parsing fails.GParses a file in SGF format. Returns an error string if parsing fails.ZParses a node as part of an existing game tree, from textual SGF "GameTree" syntax. The wH is needed to supply necessary information from the existing game tree.   None23468:MRenders an SGF 9 to a string.WRecursively renders an SGF GameTree (as defined in the spec) rooted at the given node.DRenders a node and its properties without recurring to its children. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIIJKLMNOOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@@ABBCDEEFGGHIJKLMNOPQRS T U V W W X Y Z [ \ ] ] ^ _ ` a b c d e f g h i j j k l m n o p q r s t u v w x y z { | } ~                                                                                P Q R                                            Y[]b !"#$"%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcddefghijklmnopqrstuvwxyz{|}~                                  T                                                                goatee-0.3.0Game.Goatee.Lib.RendererGame.Goatee.Common.BigfloatGame.Goatee.CommonGame.Goatee.Lib.TypesGame.Goatee.Lib.Property.ParserGame.Goatee.Lib.PropertyGame.Goatee.AppGame.Goatee.Lib.TreeGame.Goatee.Lib.BoardGame.Goatee.Lib.MonadGame.Goatee.Lib.ParserGame.Goatee.Lib.Renderer.Tree Paths_goateeData.Mapmap Data.Listsort!Game.Goatee.Lib.Property.RendererGame.Goatee.Lib.Property.ValueGame.Goatee.Lib.Property.BaseGame.Goatee.Lib.Property.InfoRender runRender rendererOfBigfloat significandexponentencode fromDoubletoDouble listDeleteAt listInsertAt listReplace listUpdate andEithersformapTuple mapInvert whenMaybecondif'andM forIndexM_whileMwhileM'doWhileM RulesetTypeRulesetNewZealandRulesetJapanese RulesetIng RulesetAgaRulesetUnknownRuleset KnownRuleset WinReason WinByForfeit WinByTimeWinByResignation WinByScore GameResultGameResultOtherGameResultUnknownGameResultVoidGameResultDraw GameResultWinMark MarkSelectedMarkX MarkTriangle MarkSquare MarkCircle LabelListLineLineList ArrowListVariationModeSourceShowCurrentVariationsShowChildVariations VariationModevariationModeSourcevariationModeBoardMarkupColorWhiteBlack DoubleValueDouble2Double1 RealValueUnknownPropertyValuefromUnknownPropertyValue SimpleTextfromSimpleTextTextfromText Stringlike sgfToString stringToSgf CoordListcoordListSinglescoordListRectsCoordsupportedFormatVersionsdefaultFormatVersionsupportedGameTypesboardSizeDefault boardSizeMin boardSizeMaxcoord1coordscoords'emptyCoordListexpandCoordListbuildCoordList starLines isStarPointhandicapStonesconvertStringliketoText toSimpleTexttoUnknownPropertyValuecnotdefaultVariationModetoVariationModefromVariationMode lineToPair fromRuleset toRulesetcomposeline colorParsercoordElistParsercoordListParsercoordPairListParser doubleParsergameResultParserlabelListParserlineListParser moveParser noneParserintegralParser realParser rulesetParsersimpleTextPairParsersimpleTextParser simpleText sizeParser textParsertextunknownPropertyParservariationModeParserValuedPropertyInfo PropertyInfoAnyCoordListDescriptorAnyValuedDescriptor AnyDescriptorValuedDescriptor propertyValuepropertyBuilder Descriptor propertyName propertyTypepropertyInheritedpropertyPredicatepropertyValueParserpropertyValueRendererpropertyValueRendererPretty PropertyTypeGeneralPropertyGameInfoProperty RootProperty SetupProperty MovePropertyPropertyUnknownPropertyTWTBKMHAVWWLOWOBBLWTWRUSTMSORUROREPWPCPBOTONGNGCEVDTCPBTBRANSZSTGMFFCAAPTRSQSLMALNLBDDCRARTEITDOBMVUCNHOGWGBDMCPLAWAEABWMNKOB defPropertydefValuedProperty propertyB propertyKO propertyMN propertyW propertyAB propertyAE propertyAW propertyPL propertyC propertyDM propertyGB propertyGW propertyHO propertyN propertyUC propertyV propertyBM propertyDO propertyIT propertyTE propertyAR propertyCR propertyDD propertyLB propertyLN propertyMA propertySL propertySQ propertyTR propertyAP propertyCA propertyFF propertyGM propertyST propertySZ propertyAN propertyBR propertyBT propertyCP propertyDT propertyEV propertyGC propertyGN propertyON propertyOT propertyPB propertyPC propertyPW propertyRE propertyRO propertyRU propertySO propertyTM propertyUS propertyWR propertyWT propertyBL propertyOB propertyOW propertyWL propertyVW propertyHA propertyKM propertyTB propertyTWallKnownDescriptorspropertyUnknown propertyInfodescriptorForNamedescriptorForName'stoneAssignmentPropertiesstoneAssignmentPropertyToStonestoneToStoneAssignmentProperty markPropertyapplicationNameapplicationCopyrightapplicationWebsiteapplicationAuthorsNodeWithDeepEqualitynodeWithDeepEqualityNodenodeProperties nodeChildrenCollectionWithDeepEqualitycollectionWithDeepEquality CollectioncollectionTrees emptyNoderootNode findProperty findProperty'findPropertyValuefindPropertyValue' addPropertyaddChild addChildAt deleteChildAt validateNodeCursorcursorChildIndex cursorBoard CoordState coordStar coordStone coordMark coordVisible coordDimmed BoardStateboardCoordStatesboardHasInvisibleboardHasDimmedboardHasCoordMarks boardArrows boardLines boardLabelsboardMoveNumberboardPlayerTurnboardBlackCapturesboardWhiteCaptures boardGameInfoGameInfogameInfoRootInfogameInfoBlackNamegameInfoBlackTeamNamegameInfoBlackRankgameInfoWhiteNamegameInfoWhiteTeamNamegameInfoWhiteRankgameInfoRulesetgameInfoBasicTimeSecondsgameInfoOvertimegameInfoResultgameInfoGameNamegameInfoGameCommentgameInfoOpeningComment gameInfoEvent gameInfoRound gameInfoPlacegameInfoDatesPlayedgameInfoSourcegameInfoCopyrightgameInfoAnnotatorNamegameInfoEntererNameRootInfo rootInfoWidthrootInfoHeightrootInfoVariationMode emptyGameInfointernalIsGameInfoNodegameInfoToProperties boardWidth boardHeightemptyBoardStaterootBoardStateemptyCoordStateboardCoordStateboardCoordModifymapBoardCoords isValidMoveisCurrentValidMove cursorParent cursorNode rootCursor cursorRoot cursorChildcursorChildrencursorChildCountcursorChildPlayingAtcursorPropertiescursorModifyNodecursorVariationsmoveToPropertyVariationModeChangedHandlerPropertiesModifiedHandlerNavigationHandlerGameInfoChangedHandlerChildDeletedHandlerChildAddedHandlerAnyEventEvent eventNameeventHandlerFromActionGoMGoTNodeDeleteResultNodeDeleteOnPathStackNodeDeleteBadIndex NodeDeleteOkMonadGo getCursor getCoordStategoUpgoDowngoLeftgoRightgoToRootgoToGameInfoNode pushPosition popPosition dropPosition getPropertiesmodifyProperties getPropertygetPropertyValue putPropertydeletePropertymodifyPropertymodifyPropertyValuemodifyPropertyStringmodifyPropertyListmodifyPropertyCoordsmodifyGameInfomodifyVariationModegetAssignedStonegetAllAssignedStonesmodifyAssignedStonesgetMark modifyMarkonon0StepGoDownGoUprunGoTevalGoTexecGoTrunGoevalGoexecGofirechildAddedEventchildDeletedEventgameInfoChangedEventnavigationEventpropertiesModifiedEventvariationModeChangedEvent parseString parseFile parseSubtreepropertyParserrenderCollectionrenderGameTreerenderPropertycatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameghc-prim GHC.TypesIntbaseGHC.ShowshowShowGHC.ReadReadDoubleshiftreduce normalize2 integer-gmpGHC.Integer.TypeIntegerlift2zeroonenegOne$fReadBigfloat$fShowBigfloat $fNumBigfloat $fOrdBigfloat $fEqBigfloat Data.EitherLeftRight Data.MaybeMaybeGHC.Listand Control.MonadforM_NothingJustGHC.BaseStringhandicapStoneIndices $fEqCoordListsanitizeSimpleText$fStringlikeRuleset$fStringlikeGameResult$fEqLine $fStringlikeUnknownPropertyValue$fStringlikeSimpleText$fStringlikeText$fStringlike[]CoordListMonoid Data.MonoidMonoidrunCoordListMonoidsinglelistOfnumbercolorcoordintegralrealtextChar variationMode$fMonoidCoordListMonoid bracketed renderLine renderCoordrenderCoordBracketedrenderCoordPrettyrenderCoordPairPrettyrenderCoordPairrenderCoordPairBracketedrenderShowablerenderStringlikerenderStringlikePrettyrenderColorBracketedrenderColorPrettyrenderCoordElistBracketedrenderCoordElistPrettyrenderCoordListBracketedrenderCoordListPrettyrenderCoordListNonemptyrenderCoordListNonemptyPrettyrenderCoordPairListBracketedrenderCoordPairListPrettyrenderDoubleBracketedrenderDoublePrettyrenderGameResultBracketedrenderGameResultPrettyrenderGameResultPretty'renderIntegralBracketedrenderIntegralPrettyrenderLabelListBracketedrenderLabelListPrettyrenderLineListBracketedrenderLineListPrettyrenderMoveBracketedrenderMovePrettyrenderNoneBracketedrenderNonePrettyrenderRealBracketedrenderRealPrettyrenderRulesetBracketedrenderRulesetPrettyrenderSimpleTextPairBracketedrenderSimpleTextPairPrettyrenderSimpleTextBracketedrenderSimpleTextPrettyrenderSizeBracketedrenderSizePrettyrenderTextBracketedrenderTextPrettyrenderUnknownPropertyBracketedrenderUnknownPropertyPrettyrenderVariationModeBracketedrenderVariationModePrettyPropertyValueType pvtParser pvtRendererpvtRendererPrettycolorPvt coordElistPvt coordListPvtcoordPairListPvt doublePvt gameResultPvt integralPvt labelListPvt lineListPvtmovePvtnonePvtrealPvt rulesetPvtsimpleTextPairPvt simpleTextPvtsizePvttextPvtunknownPropertyPvtvariationModePvtvaluedPropertyInfoNamevaluedPropertyInfoTypevaluedPropertyInfoInheritedvaluedPropertyInfoPredicatevaluedPropertyInfoValueTypevaluedPropertyInfoValuevaluedPropertyInfoBuilderpropertyInfoNamepropertyInfoInstancepropertyInfoTypepropertyInfoInherited%$fValuedDescriptorvValuedPropertyInfo$fDescriptorValuedPropertyInfo$fDescriptorPropertyInfo&$fValuedDescriptorvAnyValuedDescriptor$fDescriptorAnyValuedDescriptor$fDescriptorAnyDescriptordescriptorsByName$fDescriptorProperty GHC.ClassesEqvalidateNodeDuplicates$fEqNodeWithDeepEquality$fEqCollectionWithDeepEquality CursorNode cursorParent' cursorNode'ApplyMoveGroupApplyMoveResult applyMoveApplyMoveOverwriteErrorApplyMoveSuicideErrorApplyMoveCapture ApplyMoveOkApplyMoveParams allowSuicideallowOverwriteupdateRootInfoupdateBoardInfo boardChildboardResetForChildboardApplyChildsetBoardVisibleclearBoardDimmed applyPropertyupdateCoordStatesupdateBoardForMovestandardGoMoveParamsplayTheDarnMoveGoParamsgetApplyMoveResult maybeCaptureadjacentPointsgetLibertiesOfGroup bucketFill ModifiedNodeUnmodifiedNode getCursorNodeapplyMoveGroupOriginapplyMoveGroupCoordsapplyMoveGroupLibertiesapplyPropertiesupdateCoordStates'getApplyMoveResult' computeGroupapplyMoveCapture$fShowCoordState$fShowBoardStateOrd PathStackGoState stateCursorstatePathStackstateChildAddedHandlersstateChildDeletedHandlersstateGameInfoChangedHandlersstateNavigationHandlersstatePropertiesModifiedHandlers!stateVariationModeChangedHandlers initialState reverseSteptakeStep takeStepMgoUp'goDown' getPathStack foldPathStackeventStateGettereventStateSettergoStategetStateputState modifyStatedoesPathStackEnterCurrentNode addHandler$fShowAnyEvent $fOrdAnyEvent $fEqAnyEvent $fShowEvent $fOrdEvent $fEqEvent $fMonadGoGoT$fMonadWriterwGoT$fMonadStatesGoT $fMonadIOGoT$fMonadTransGoT $fMonadGoT$fApplicativeGoT $fFunctorGoTcheckFormatVersionpostProcessTreeconvertNodeTtToPassconvertPropertyTtToPasscollectionParsergameTreeParser nodeParser renderNode