!ύ;      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                             ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : Safe ;<=>?ACV goatee2A string containing the name of this application, "Goatee".goatee%A user-presentable copyright message.goatee$The home page for Goatee on the web.goatee!A list of contributors to Goatee.Safe ;<=>?ACVA%goateepDrops the element at an index from a list. If the index is out of bounds then the list is returned unmodified.goateeInserts 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.goateelistReplace old new list replaces all occurrences of old with new in list.goatee3Modifies the element at a specific index in a list.goateeIf any item is a ;, then the list of ;&s is returned, otherwise the list of <s is returned. goateefor is flip map. goatee.Transforms both values in a homogeneous tuple. goateeInverts 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. goatee#Executes the monadic function if a = contains a value. goateeFinds 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.goateeA function form of if that takes its test last.goatee> 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.goatee?/ that also passes in the index of each element.goateewhileM test body repeatedly evaluates test% until it returns false. Every time test returns true, body is executed once.goateewhileM' test body repeatedly evaluates test until it returns @. Every time it returns a A, that value is passed to body and the result is executed.goateedoWhileM 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 ;<=>?ACV]hgoateeA 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 BM, because some operations may break if the exponent is larger (specifically C and +). This shouldn't be an issue for Goatee.%These values form an integral domain.The DT 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 E. instance accepts numbers matching the regex -?\d+(\.\d+)?(e-?\d+)?R. Scientific exponent notation is supported for reading, for ease of converting Fs to s.goateeencode significand exponent creates a  value whose numeric value is significand * (10 ^ exponent).goatee Converts a F to a  (with as much precision as the F D instance provides).goatee Converts a  to a F , lossily.Ggoateeshift 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.Hgoatee Reduces a g to canonical form, keeping the numeric value the same but removing trailing zeros from the numerator.Igoatee Converts two @s so that they have the same number of decimal places, so that J0 arithmetic may be performed directly on their s.KgoateeLifts a function on two Js 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 ;<=>?ACVcgoateeGA monad for accumulating string output with the possibility of failure. goatee`Returns either the rendered result on the right, or a message describing a failure on the left.!goateeWraps 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 ;<=>?ACVU9"goatee<The rulesets defined by the SGF specification, for use with '.'goateepA ruleset used for a Go game. Can be one of the rulesets defined by the SGF specification, or a custom string.5goatee;The markings that SGF supports annotating coordinates with.;goateebA list of labels, each specified with a string and a coordinate about which to center the string.<goatee+An undirected line between two coordinates.>goatee#A list of lines, each specified as (startCoord, endCoord).?goatee$A list of arrows, each specified as (startCoord, endCoord).@goatee9An enumeration that describes which variations are shown.Agoatee"Show children of the current move.Bgoatee&Show alternatives to the current move.CgoateeZSGF flags that control how move variations are to be presented while displaying the game.Egoatee%Which moves to display as variations.Fgoatee+Whether to overlay variations on the board.GgoateeStone color: black or white.Jgoatee1An SGF double value: either 1 or 2, nothing else.Mgoatee?An SGF real value is a decimal number of unspecified precision.NgoateeThe value type for an UnknownProperty&. Currently represented as a string.Ogoatee(Returns the string contained within the UnknownProperty this value is from.PgoateeAn SGF SimpleText value.QgoateeConverts an SGF P to a string.RgoateeAn SGF text value.SgoateeConverts an SGF R to a string.TgoateeBA class for SGF data types that are coercable to and from strings.&The construction of an SGF value with V 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 L instance is defined with sgfToString = stringToSgf = id+. For other types, the string returned by U 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.Ugoatee,Extracts the string value from an SGF value.Vgoatee)Creates an SGF value from a string value.WgoateeFA 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).XgoateeReturns the single points in a W.YgoateeReturns the rectangles in a W.ZgoateeA 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.[goatee7The FF versions supported by Goatee. Currently only 4.\goatee$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.]goateeqSGF supports multiple game types. This list contains the game types that Goatee supports, which is only Go (1).^goateecThe default size of the board. The FF[4] SGF spec says that the default Go board is 19x19 square._goatee+The minimum board size allowed by FF[4], 1.`goatee,The maximum board size allowed by FF[4], 52.agoatee Constructs a W containing a single point.bgoatee Constructs a WD containing the given single points. For rectangle detection, use f.cgoatee Constructs a W3 containing the given single points and rectangles.dgoateeA W that contains no points.egoateeConverts a compact W to a list of coordinates.fgoatee Constructs a W from a list of Zks, doing some not-completely-stupid rectangle detection. The order of data in the result is unspecified.ggoateestarLines width height returns AV 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.hgoateeisStarPoint width height x y determines whether (x, y)A is a known star point on a board of the given width and height.MgoateehandicapStoneIndices !! 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 Z ordering.igoatee$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 @.jgoateeConverts between T types via a string. -convertStringlike = stringToSgf . sgfToStringkgoateeConverts a string to an SGF R.lgoateeConverts a string to an SGF P>, replacing all whitespaces (including newlines) with spaces.mgoateeConstructs a value for a UnknownProperty.ngoateeNReturns the logical negation of a stone color, yang for yin and yin for yang.ogoatee9The default variation mode as defined by the SGF spec is 'VariationMode ShowChildVariations True.pgoateeMParses a numeric variation mode, returning nothing if the number is invalid.qgoatee/Returns the integer value for a variation mode.rgoatee Converts a < to a pair of Z$s representing the line's endpoints.sgoatee0Returns the string representation for a ruleset.tgoatee,Parses a string representation of a ruleset.ugoateeFEquality is based on unordered, set equality of the underlying points.S"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWYXZ[\]^_`abcdefghijklmnopqrstS[\]^_`ZWXYabcdefghiTUVjRSkPQlNOmMJKLGHInCDEF@ABopq?><=r;56789:/01234*+,-.'()"#$%&stSafe ;<=>?ACVs'NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstSafe ;<=>?ACV:ugoateeA wrapper around W with a v 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.goatee,A parser for SGF SimpleText property values.goatee|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 ']'.Safe ;<=>?ACVpwxyz{|}~None ;<=>?ACV&dgoateebMetadata for a property that contains a value. Corresponds to a non-nullary data constructor of .goateeOThe SGF textual name for the property (also the name of the data constructor).goateeThe SGF property type.goatee"Whether the property is inherited.goatee2A predicate that matches predicates to which this  applies.goatee0Metadata about the type of the property's value.goatee?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.goatee5A function that builds a property containing a value.goateefMetadata for a property that does not contain a value. Corresponds to a nullary data constructor of .goatee&The SGF textual name for the property.goatee$The single instance of the property.goateeThe SGF property type.goatee"Whether the property is inherited.goateepAn existential type for any descriptor of a property that holds a value of a specific type. Has instances for  and , similar to .goatee2An 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.goatee A class for )s of properties that also contain values.goateexExtracts the value from a property of the given type. Behaviour is undefined if the property is not of the given type.goatee%Builds a property from a given value.goatee0A 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 .goatee7Returns the name of the property, as used in SGF files.goatee?Returns the type of the property, as specified by the SGF spec.goateeReturns 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.goatee@Returns whether the given property has the type of a descriptor.goatee0A parser of property values in SGF format (e.g. "[ab]"% for a property that takes a point).goatee/A renderer property values to SGF format (e.g. B (Just (1,2)) renders to "[ab]").goateecA renderer for displaying property values in a UI. Displays the value in a human-readable format.goatee5The property types that SGF uses to group properties.goateeCannot mix with setup nodes.goateeCannot mix with move nodes.goateeMay only appear in root nodes.goateeAt most one on any path.goatee%May appear anywhere in the game tree.goatee: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.goateeBlack move (nothing iff pass).goatee/Execute move unconditionally (even if illegal).goateeAssign move number.goateeWhite move (nothing iff pass).goateeAssign black stones.goateeAssign empty stones.goateeAssign white stones.goateePlayer to play.goateeComment.goateeEven position.goateeGood for black.goateeGood for white.goateeHotspot.goatee Node name.goateeUnclear position.goatee Node value.goatee Bad move.goateeDoubtful move.goateeInteresting move.goateeTesuji.goateeArrows.goateeMark points with circles.goatee Dim points.goateeLabel points with text.goateeLines.goateeMark points with Xs.goateeMark points as selected.goateeMark points with squares.goateeMark points with trianges.goateeApplication info.goatee Charset for SimpleText and Text.goateeFile format version.goateeGame (must be 1 = Go).goateeVariation display format.goateeBoard size, columns then rows.goateeName of annotator.goateeRank of black player.goateeName of black team.goateeCopyright info.goatee Dates played.goatee Event name.goatee(Game comment, or background, or summary.goatee Game name.goateeInformation about the opening.goateeThe method used for overtime.goateeName of black player.goateeWhere the game was played.goateeName of white player. goateeResult of the game. goatee Round info. goatee Ruleset used. goateeSource of the game. goateeTime limit, in seconds.goatee-Name of user or program who entered the game.goateeRank of white player.goateeName of white team.goateeBlack time left.goatee$Black moves left in byo-yomi period.goatee$White moves left in byo-yomi period.goateeWhite time left.goateeSet viewing region.goateeHandicap stones (>=2).goateeKomi.goateeBlack territory.goateeWhite territory.goatee}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.goateeuInternal 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 Z) that is a B and is not inherited. The value type is automatically inferred.goatee%The SGF textual name of the property.goateeThe name of the .goatee"Whether the property is inherited.^     None ;<=>?ACV8 ^goatee$A list of descriptors for all known s._goatee Builds a / for an unknown property with the given name. 1Does not check that the name is actually unknown.`goateeReturns 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.agoateeReturns a descriptor for the given property name. The name does not have to be for a known property; an unknown property will use _.bgoateeBReturns a descriptor for a known property with the given name, or @2 if the name does not belong to a known property.cgoateeQDescriptors for setup properties that assign stones to the board. For use with d and e.dgoateeConverts a descriptor in c" to the type of stone it assigns.egoatee8Converts a type of stone assignment to a descriptor in c.fgoatee"Returns the descriptor for a mark.J !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefNone ;<=>?ACV9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefSafe ;<=>?ACV?None ;<=>?ACVZggoateeA wrapper around j 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 j directly because it is not the only obvious sense of equality (only comparing properties would be another one), and it's also potentially expensive.jgoateeAn 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.ngoateeSee g.qgoatee An SGF collection of game trees.tgoatee*A node with no properties and no children.ugoateeReturns a fresh root j with 9 set to Goatee and optionally with a board size set via .vgoatee;Searches for a matching property in a node's property list.wgoatee4Searches for a matching property in a property list.xgoatee<Retrieves the value of a property in a node's property list.ygoatee5Retrieves the value of a property in a property list.zgoatee-Appends a property to a node's property list.{goateeaddChild child parent- appends a child node to a node's child list.|goateeaddChildAt 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.}goateedeleteChildAt index nodeP deletes the child at the given index from the node. If the index is invalid, node is returned.~goateecReturns a list of validation errors for the current node, an empty list if no errors are detected.ghijklmnopqrstuvwxyz{|}~qrsnopjklmghituvwxyz{|}~ None ;<=>?ACV_OgoateeRenders an SGF q to a string.goateeWRecursively renders an SGF GameTree (as defined in the spec) rooted at the given node.goateeDRenders a node and its properties without recurring to its children. None ;<=>?ACV?;goateeKeeps track of a cursor's node. Also records whether the node has been modified, and uses separate data constructors to force consideration of this.goateeqA pointer to a node in a game tree that also holds information about the current state of the game at that node.goateeThe 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.goateeThe 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.goateeDThe 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.goatee.The complete board state for the current node.goateeXInternal data structure, only for move application code. Represents a group of stones.goateeThe possible results from .goateeOThe move was accepted; playing it resulted in the given board without capture.goateeThe move was accepted; playing it resulted in the given board with a capture. The specified side gained the number of points given.goatee=Playing the move would result in suicide, which is forbidden.goateecThere is already a stone of the specified color on the target point, and overwriting is forbidden.goatee A structure that configures how 6 should handle moves that are normally illegal in Go.goateeIf false, suicide will cause  to return R. If true, suicide will kill the friendly group and give points to the opponent.goatee3If 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.goateeUsed by  to represent the state of a single point on the board. Records whether a stone is present, as well as annotations and visibility properties.goatee#Whether this point is a star point.goateeAn 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.goateePThe state of individual points on the board. Stored in row-major order. Point (x, y) can be accessed via  !! y !! x (but prefer ).goateeWhether any of the board's gs are invisible. This is an optimization to make it more efficient to set the board to "all visible."goateeWhether any of the board's gs are dimmed. This is an optimization to make it more efficient to clear all dimming from the board.goateeWhether any of the board's  s have a 5 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.goatee1Properties that are specified in game info nodes.goatee>Properties that are specified in the root nodes of game trees.goatee Builds a  with the given  and no extra data.goatee9Returns whether a node contains any game info properties.goatee Converts a  into a list of 's that can be used to reconstruct the .goatee*Returns the width of the board, in stones.goatee+Returns the height of the board, in stones.goatee Creates a 2 for an empty board of the given width and height.goateeA ! for an empty point on the board.goatee Returns the  for a coordinate on a board.goatee Modifies a  by updating the  at a single point.goateeMaps a function over each  in a V, returning a list-of-lists with the function's values. The function is called like fn y x coordState.goatee!Applies a function to update the  within the  of a .goatee!Applies a function to update the  of a .goateeGiven a D for a parent node, and a child node, this function constructs the  for the child node.goatee Performs necessary updates to a G between nodes in the tree. Clears marks. This is the first step of .goatee0Applies a child node's properties to a prepared . This is the second step of .goateeXSets all points on a board to be visible (if given true) or invisible (if given false).goatee.Resets all points on a board not to be dimmed.goateeApplies a property to a 4. This function covers all properties that modify 4s, including making moves, adding markup, and so on.goateeXApplies the transformation function to all of a board's coordinates referred to by the W.goateeUpdates properties of a z given that the player of the given color has just made a move. Increments the move number and updates the player turn.goateeAs an argument to 0, causes illegal moves to be treated as errors.goateeAs an argument to 5, causes illegal moves to be played unconditionally.goateeIf the 3 represents a successful move, then the resulting % is returned, otherwise, the default  given is returned.goateePlaces 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.goateeCapture 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.goateeReturns a list of the four coordinates that are adjacent to the given coordinate on the board, excluding coordinates that are out of bounds.goateeNTakes 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.goateeExpands 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).goateeReturns 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.goateeReturns 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.goateeThe 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.goatee=The game tree node about which the cursor stores information.goatee!Returns a cursor for a root node.goateeThis is simply l . .goateegReturns 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.NN None ;<=>?ACVlgoateeIParses a string in SGF format. Returns an error string if parsing fails.goateeGParses a file in SGF format. Returns an error string if parsing fails.goateeZParses a node as part of an existing game tree, from textual SGF "GameTree" syntax. The H is needed to supply necessary information from the existing game tree. None ;<=>?ACVSgoateeA handler for &Js. It is called with the old variation mode then the new variation mode.goateeA handler for %Hs. It is called with the old property list then the new property list.goateeA 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.goateeA handler for #@s. It is called with the old game info then the new game info.goateeA handler for "_s. It is called with a cursor at the child that was deleted (this cursor is now out of date).goateeA handler for !Bs. Called with the index of the child added to the current node.goateeBAn existential type for any event in a particular Go monad. Like , the , , and D" instances use events' names, via .goateeKA 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 D" instances use events' names, via .goateeThe standard monad for .goatee#The standard monad transformer for .goateeThe result of deleting a node.goatee"The node was deleted successfully.goateeAThe node couldn't be deleted, because an invalid index was given.goatee>The node couldn't be deleted, because it is on the path stack.goatee2A monad (transformer) for navigating and mutating -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.goateeReturns the current cursor.goatee Returns the  at the given point.goatee)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.goateeDNavigates 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.goateeIf 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.goateeIf 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.goatee-Navigates up to the root of the tree. Fires $s for each step.goateexNavigates up the tree to the node containing game info properties, if any. Returns true if a game info node was found.goateeYPushes 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).goateeJReturns to the last position pushed onto the internal position stack via %. This action must be balanced by a .goatee:Drops the last position pushed onto the internal stack by 7 off of the stack. This action must be balanced by a .goatee2Returns the set of properties on the current node.goatee<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).goateeCSearches for a property on the current node, returning it if found.goateeRSearches for a valued property on the current node, returning its value if found.goateeoSets a property on the current node, replacing an existing property with the same name, if one exists. Fires % if the property has changed.goateeBDeletes 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 propertyPLgoateegCalls 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 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.goateenCalls 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 AB 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.goatee8Mutates 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. goatee+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  . goatee Mutates the Wd-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. goateeMutates 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. goateeSets the game's C via the * property on the root node, then fires a &# if the variation mode has changed. goatee?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.goatee)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.goatee\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 AT, then we create a child node with the necessary assignment properties, insert it (!), then navigate to it ($). If the function returns @, then  does nothing.goatee Returns the 5 at a point on the current node.goatee5Calls the given function to modify the presence of a 5 on the current node.goatee]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.goateeAdds 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.goateeTries 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.goatee5Registers a new event handler for a given event type.goatee>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.goatee4A single step along a game tree. Either up or down.goatee7Represents a step up from a child with the given index.goatee9Represents a step down to the child with the given index.goateeA 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.goatee/The internal state of a Go monad transformer. go6 is the type of Go monad or transformer (instance of GoMonad).goatee&The current position in the game tree.goateeThe current path stack.goatee Handlers for !.goatee Handlers for ".goatee Handlers for #.goatee Handlers for $.goatee Handlers for %.goatee Handlers for &.goatee&A simplified constructor function for .goatee]Reverses a step, such that taking a step then it's reverse will leave you where you started.goateeTakes a  from a , returning a new .goateeInternal 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.goateeExecutes a Go monad transformer on a cursor, returning in the underlying monad a tuple that contains the resulting value and the final cursor.goateemExecutes a Go monad transformer on a cursor, returning in the underlying monad the value in the transformer.goateeaExecutes a Go monad transformer on a cursor, returning in the underlying monad the final cursor.goatee"Runs a Go monad on a cursor. See .goatee?Runs a Go monad on a cursor and returns the value in the monad.goatee9Runs a Go monad on a cursor and returns the final cursor.goateeTakes 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.goateeTakes 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.goateeReturns the current path stack.goateetMaps over a path stack, updating with the given functions all steps that enter and leave the cursor's current node. goateeFires 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).!goateeGAn event corresponding to a child node being added to the current node."goateeNAn event corresponding to the deletion of one of the current node's children.#goateeAn 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.$goateeMAn event that is fired when a single step up or down in a game tree is made.%goateeUAn event corresponding to a modification to the properties list of the current node.&goatee1An event corresponding to a change in the active C'. This can happen when modifying the ] property, and also when navigating between collections (as they have different root nodes).goateevWhen no node with game info is found, then if false, return to the original node, otherwise finish at the root node.D      !"#$%&D      !"#$%& !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRRSTUVWXXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxxyzz{|}}~                                                                                                                                                         ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?@AB@AC@DE@FG@FH@DI@DJKLM@NO@NP@QRKLSTUVWXYZ@D[\]^_`abcdefghijklmnopqrstuvwxyz{|}~@DK                               K                  %goatee-0.3.1.3-7CjZhTFHzAJ5rUppdAvMJHGame.Goatee.AppGame.Goatee.CommonGame.Goatee.Common.BigfloatGame.Goatee.Lib.RendererGame.Goatee.Lib.TypesGame.Goatee.Lib.Property.ParserGame.Goatee.Lib.PropertyGame.Goatee.Lib.TreeGame.Goatee.Lib.Renderer.TreeGame.Goatee.Lib.BoardGame.Goatee.Lib.ParserGame.Goatee.Lib.MonadData.Mapmap Data.Listsort!Game.Goatee.Lib.Property.RendererGame.Goatee.Lib.Property.ValueGame.Goatee.Lib.Property.BaseGame.Goatee.Lib.Property.Info Paths_goateeapplicationNameapplicationCopyrightapplicationWebsiteapplicationAuthors listDeleteAt listInsertAt listReplace listUpdate andEithersformapTuple mapInvert whenMaybecondif'andM forIndexM_whileMwhileM'doWhileMBigfloat significandexponentencode fromDoubletoDouble$fReadBigfloat$fShowBigfloat $fNumBigfloat $fOrdBigfloat $fEqBigfloatRender runRender rendererOf RulesetType RulesetAga RulesetIngRulesetJapaneseRulesetNewZealandRuleset KnownRulesetUnknownRuleset WinReason WinByScoreWinByResignation WinByTime WinByForfeit GameResult GameResultWinGameResultDrawGameResultVoidGameResultUnknownGameResultOtherMark MarkCircle MarkSquare MarkTriangleMarkX MarkSelected LabelListLineLineList ArrowListVariationModeSourceShowChildVariationsShowCurrentVariations VariationModevariationModeSourcevariationModeBoardMarkupColorBlackWhite DoubleValueDouble1Double2 RealValueUnknownPropertyValuefromUnknownPropertyValue SimpleTextfromSimpleTextTextfromText Stringlike sgfToString stringToSgf CoordListcoordListSinglescoordListRectsCoordsupportedFormatVersionsdefaultFormatVersionsupportedGameTypesboardSizeDefault boardSizeMin boardSizeMaxcoord1coordscoords'emptyCoordListexpandCoordListbuildCoordList starLines isStarPointhandicapStonesconvertStringliketoText toSimpleTexttoUnknownPropertyValuecnotdefaultVariationModetoVariationModefromVariationMode lineToPair fromRuleset toRuleset $fEqCoordList$fStringlike[]$fStringlikeText$fStringlikeSimpleText $fStringlikeUnknownPropertyValue$fEqLine$fStringlikeGameResult$fStringlikeRuleset$fShowCoordList$fEqText $fShowText$fEqSimpleText$fShowSimpleText$fEqUnknownPropertyValue$fShowUnknownPropertyValue$fBoundedDoubleValue$fEnumDoubleValue$fEqDoubleValue$fOrdDoubleValue$fShowDoubleValue$fBoundedColor $fEnumColor $fEqColor $fOrdColor $fShowColor$fBoundedVariationModeSource$fEnumVariationModeSource$fEqVariationModeSource$fOrdVariationModeSource$fShowVariationModeSource$fEqVariationMode$fShowVariationMode $fShowLine $fBoundedMark $fEnumMark$fEqMark $fOrdMark $fShowMark $fEqWinReason$fShowWinReason$fEqGameResult$fShowGameResult$fBoundedRulesetType$fEnumRulesetType$fEqRulesetType$fOrdRulesetType$fShowRulesetType $fEqRuleset $fShowRulesetcomposeline colorParsercoordElistParsercoordListParsercoordPairListParser doubleParsergameResultParserlabelListParserlineListParser moveParser noneParserintegralParser realParser rulesetParsersimpleTextPairParsersimpleTextParser simpleText sizeParser textParsertextunknownPropertyParservariationModeParser$fMonoidCoordListMonoid$fSemigroupCoordListMonoidValuedPropertyInfo PropertyInfoAnyCoordListDescriptorAnyValuedDescriptor AnyDescriptorValuedDescriptor propertyValuepropertyBuilder Descriptor propertyName propertyTypepropertyInheritedpropertyPredicatepropertyValueParserpropertyValueRendererpropertyValueRendererPretty PropertyType MoveProperty SetupProperty RootPropertyGameInfoPropertyGeneralPropertyPropertyBKOMNWABAEAWPLCDMGBGWHONUCVBMDOITTEARCRDDLBLNMASLSQTRAPCAFFGMSTSZANBRBTCPDTEVGCGNONOTPBPCPWRERORUSOTMUSWRWTBLOBOWWLVWHAKMTBTWUnknownProperty 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 markPropertyNodeWithDeepEqualitynodeWithDeepEqualityNodenodeProperties nodeChildrenCollectionWithDeepEqualitycollectionWithDeepEquality CollectioncollectionTrees emptyNoderootNode findProperty findProperty'findPropertyValuefindPropertyValue' addPropertyaddChild addChildAt deleteChildAt validateNode$fEqNodeWithDeepEquality$fEqCollectionWithDeepEquality $fShowNode$fShowCollection $fShowCollectionWithDeepEqualityrenderCollectionrenderGameTreerenderPropertyCursorcursorChildIndex cursorBoard CoordState coordStar coordStone coordMark coordVisible coordDimmed BoardStateboardCoordStatesboardHasInvisibleboardHasDimmedboardHasCoordMarks boardArrows boardLines boardLabelsboardMoveNumberboardPlayerTurnboardBlackCapturesboardWhiteCaptures boardGameInfoGameInfogameInfoRootInfogameInfoBlackNamegameInfoBlackTeamNamegameInfoBlackRankgameInfoWhiteNamegameInfoWhiteTeamNamegameInfoWhiteRankgameInfoRulesetgameInfoBasicTimeSecondsgameInfoOvertimegameInfoResultgameInfoGameNamegameInfoGameCommentgameInfoOpeningComment gameInfoEvent gameInfoRound gameInfoPlacegameInfoDatesPlayedgameInfoSourcegameInfoCopyrightgameInfoAnnotatorNamegameInfoEntererNameRootInfo rootInfoWidthrootInfoHeightrootInfoVariationMode emptyGameInfointernalIsGameInfoNodegameInfoToProperties boardWidth boardHeightemptyBoardStaterootBoardStateemptyCoordStateboardCoordStateboardCoordModifymapBoardCoords isValidMoveisCurrentValidMove cursorParent cursorNode rootCursor cursorRoot cursorChildcursorChildrencursorChildCountcursorChildPlayingAtcursorPropertiescursorModifyNodecursorVariationsmoveToProperty$fShowCoordState$fShowBoardState $fEqRootInfo$fShowRootInfo$fShowGameInfo$fEqCoordState$fShowApplyMoveParams$fShowApplyMoveGroup$fShowCursorNode $fShowCursor parseString parseFile parseSubtreepropertyParserVariationModeChangedHandlerPropertiesModifiedHandlerNavigationHandlerGameInfoChangedHandlerChildDeletedHandlerChildAddedHandlerAnyEventEvent eventNameeventHandlerFromActionGoMGoTNodeDeleteResult NodeDeleteOkNodeDeleteBadIndexNodeDeleteOnPathStackMonadGo getCursor getCoordStategoUpgoDowngoLeftgoRightgoToRootgoToGameInfoNode pushPosition popPosition dropPosition getPropertiesmodifyProperties getPropertygetPropertyValue putPropertydeletePropertymodifyPropertymodifyPropertyValuemodifyPropertyStringmodifyPropertyListmodifyPropertyCoordsmodifyGameInfomodifyVariationModegetAssignedStonegetAllAssignedStonesmodifyAssignedStonesgetMark modifyMarkonon0StepGoUpGoDownrunGoTevalGoTexecGoTrunGoevalGoexecGofirechildAddedEventchildDeletedEventgameInfoChangedEventnavigationEventpropertiesModifiedEventvariationModeChangedEvent $fShowEvent $fOrdEvent $fEqEvent$fShowAnyEvent $fOrdAnyEvent $fEqAnyEvent $fMonadGoGoT$fMonadWriterwGoT$fMonadStatesGoT $fMonadIOGoT$fMonadTransGoT $fMonadGoT$fApplicativeGoT $fFunctorGoT$fEqStep $fShowStep$fBoundedNodeDeleteResult$fEnumNodeDeleteResult$fEqNodeDeleteResult$fShowNodeDeleteResultbase Data.EitherLeftRightGHC.BaseMaybe Data.FoldableandforM_NothingJustghc-prim GHC.TypesIntGHC.ShowshowShowGHC.ReadReadDoubleshiftreduce normalize2 integer-gmpGHC.Integer.TypeIntegerlift2StringhandicapStoneIndicesrenderColorBracketedrenderColorPrettyrenderCoordElistBracketedrenderCoordElistPrettyrenderCoordListBracketedrenderCoordListPrettyrenderCoordPairListBracketedrenderCoordPairListPrettyrenderDoubleBracketedrenderDoublePrettyrenderGameResultBracketedrenderGameResultPrettyrenderGameResultPretty'renderIntegralBracketedrenderIntegralPrettyrenderLabelListBracketedrenderLabelListPrettyrenderLineListBracketedrenderLineListPrettyrenderMoveBracketedrenderMovePrettyrenderNoneBracketedrenderNonePrettyrenderRealBracketedrenderRealPrettyrenderRulesetBracketedrenderRulesetPrettyrenderSimpleTextPairBracketedrenderSimpleTextPairPrettyrenderSimpleTextBracketedrenderSimpleTextPrettyrenderSizeBracketedrenderSizePrettyrenderTextBracketedrenderTextPrettyrenderUnknownPropertyBracketedrenderUnknownPropertyPrettyrenderVariationModeBracketedrenderVariationModePrettyCoordListMonoidMonoidPropertyValueTypepvtRendererPretty pvtRenderer pvtParsercolorPvt coordElistPvt coordListPvtcoordPairListPvt doublePvt gameResultPvt integralPvt labelListPvt lineListPvtmovePvtnonePvtrealPvt rulesetPvtsimpleTextPairPvt simpleTextPvtsizePvttextPvtunknownPropertyPvtvariationModePvtvaluedPropertyInfoNamevaluedPropertyInfoTypevaluedPropertyInfoInheritedvaluedPropertyInfoPredicatevaluedPropertyInfoValueTypevaluedPropertyInfoValuevaluedPropertyInfoBuilderpropertyInfoNamepropertyInfoInstancepropertyInfoTypepropertyInfoInheritedversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName GHC.ClassesEq renderNode CursorNode cursorParent' cursorNode'ApplyMoveGroupApplyMoveResult applyMove ApplyMoveOkApplyMoveCaptureApplyMoveSuicideErrorApplyMoveOverwriteErrorApplyMoveParams allowSuicideallowOverwriteupdateRootInfoupdateBoardInfo boardChildboardResetForChildboardApplyChildsetBoardVisibleclearBoardDimmed applyPropertyupdateCoordStatesupdateBoardForMovestandardGoMoveParamsplayTheDarnMoveGoParamsgetApplyMoveResult maybeCaptureadjacentPointsgetLibertiesOfGroup bucketFillOrd PathStackGoState stateCursorstatePathStackstateChildAddedHandlersstateChildDeletedHandlersstateGameInfoChangedHandlersstateNavigationHandlersstatePropertiesModifiedHandlers!stateVariationModeChangedHandlers initialState reverseSteptakeStep takeStepMgoUp'goDown' getPathStack foldPathStack