(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv w x y z { | } ~                                             Safe-Inferred   Safe-InferredHA monad for accumulating string output with the possibility of failure. KReturns either the rendered result on the right, or a message describing a  failure on the left. DWraps 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-Inferred0<The rulesets defined by the SGF specification, for use with . IA 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. LA list of labels, each specified with a string and a coordinate about which  to center the string. #A list of lines, each specified as (startCoord, endCoord). $A list of arrows, each specified as (startCoord, endCoord). :An enumeration that describes which variations are shown. 'Show alternatives to the current move. !#Show children of the current move. "ESGF 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. )2An SGF double value: either 1 or 2, nothing else. ,The value type for an UnknownProperty. Currently represented as a  string. -(Returns the string contained within the UnknownProperty this value is  from. .An SGF SimpleText value. /Converts an SGF . to a string. 0An SGF text value. 1Converts an SGF 0 to a string. 2CA class for SGF data types that are coercable to and from strings. &The construction of an SGF value with 4 may process the input, M such that the resulting stringlike value does not represent the same string K as the input. In other words, the following does *not* necessarily hold:  ? sgfToString . stringToSgf = id (does not necessarily hold!) "The following does hold, however:  stringToSgf . sgfToString = id 3-Extracts the string value from an SGF value. 4*Creates an SGF value from a string value. 5An SGF real value. 6KA structure for compact representation of a list of coordinates. Contains H a list of individual points, as well as a list of rectangles of points O denoted by an ordered pair of the upper-left point and the lower-right point. O 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 7 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: K 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)4 (otherwise the point belongs in the singles list). 7Returns the single points in a 6. 8Returns the rectangles in a 6. 9A coordinate on a Go board. (0, 0)$ refers to the upper-left corner of H the board. The first component is the horizontal position; the second % component is the vertical position. ;$The default SGF version to use when FF[]" is not specified in a root node. IThis value is actually INCORRECT: SGF defines it to be 1, but because we  don'Ht support version 1 yet, for the sake of ignoring this issue (for now!) ' in tests, we fix the default to be 4. 6TODO Fix the default version to be 1 as SGF mandates. =(The default size of the board. The FF[4]# SGF spec says that the default Go  board is 19x19 square. >&The minimum board size allowed by FF[4], 1. ?&The maximum board size allowed by FF[4], 52. @ Constructs a 6 containing a single point. A Constructs a 64 containing the given single points. For rectangle  detection, use E. B Constructs a 64 containing the given single points and rectangles. CA 6 that contains no points. DConverts a compact 6 to a list of coordinates. E Constructs a 6 from a list of 9s, doing some M not-completely-stupid rectangle detection. The order of data in the result  is unspecified. FConverts a string to an SGF 0. GConverts a string to an SGF ., replacing all whitespaces # (including newlines) with spaces. HConstructs a value for a UnknownProperty. I@Returns the logical negation of a stone color, yang for yin and  yin for yang. J9The default variation mode as defined by the SGF spec is VariationMode  ShowChildVariations True. KDParses a numeric variation mode, returning nothing if the number is  invalid. L0Returns the integer value for a variation mode. M1Returns the string representation for a ruleset. N-Parses a string representation of a ruleset. GEquality is based on unordered, set equality of the underlying points. U  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNL  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNQ:;<=>?967878@ABCDE5234011F.//G,--H)+*&('I"#$%! JKL   MN-  ! "#$%&(')+*,-./0123456789:;<=>?@ABCDEFGHIJKLMN Safe-InferredA wrapper around 6 with a  instance used for parsing. O The monoid does simple concatenation of the single and rectangle lists, so it  is not appropriate for  CoordList proper, as it doesn't do duplicate removal  between two  CoordLists. ^-A parser for SGF SimpleText property values. bKA parser for SGF text property values. Its argument should be true if the 1 text is inside of a composed property value, so ':' should terminate the  value in addition to ']'. %OPQRSTUVWXYZ[\]^_`abcdOPQRSTUVWXYZ[\]^_`abcdQRSTUVWXYZ[\]^`acdOP_b#OPQRSTUVWXYZ[\]^_`abcd  Safe-Inferred1$1 Safe-Inferredefgh     efgh     efgh     NoneZiHMetadata for a property that contains a value. Corresponds to a single  unary data constructor of . AThe SGF textual name for the property (also the name of the data  constructor). The SGF property type. #Whether the property is inherited. 2A predicate that matches predicates to which this i  applies. 'Metadata about the type of the property' s value. >A function that extracts values from properties to which this  i6 applies. It is invalid to call this function with a  different type of property. 6A function that builds a property containing a value. kIMetadata for a property that does not contain a value. Corresponds to a $ single nullary data constructor of . 'The SGF textual name for the property. %The single instance of the property. The SGF property type. #Whether the property is inherited. l A class for qs of s that also contain values. mDExtracts the value from a property of the given type. Behaviour is 5 undefined if the property is not of the given type. n&Builds a property from a given value. q0A class for types that contain metadata about a . r8Returns the name of the property, as used in SGF files. s@Returns the type of the property, as specified by the SGF spec. tFReturns whether the value of the given property is inherited from the L lowest ancestor specifying the property, when the property is not set on a  node itself. uAReturns whether the given property has the type of a descriptor. v0A parser of property values in SGF format (e.g. [ab] for a property  that takes a point). w/A renderer property values to SGF format (e.g. B (Just (1,2)) renders  to [ab]). xJA renderer for displaying property values in a UI. Displays the value in  a human-readable format. y6The property types that SGF uses to group properties. z&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. Set viewing region. 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. 0Execute move unconditionally (even if illegal). Black move (nothing iff pass). HTemplate Haskell function to declare a property that does not contain a  value.  ) $(defProperty "KO" 'MoveProperty False) This example declares a propertyKO :: k that is a  ~ and is not inherited. GTemplate Haskell function to declare a property that contains a value.  A $(defValuedProperty "B" 'MoveProperty False 'maybeCoordPrinter) This example declares a  propertyB :: i (Maybe 9)  that is a ~* and is not inherited. The value type is  automatically inferred. cijklmnopqrstuvwxyz{|}~&The SGF textual name of the property. The name of the y. #Whether the property is inherited.  !"Sijklmnopqrstuvwxyz{|}~ ijklmnopqrstuvwxy~}|{z: !"None#Returns the descriptor for a mark. A#@A#Noneefghijklmnopqrstuvwxyz{|}~y~}|{zqrstuvwxoplmnkijefghfgh Safe-InferredThis sequences ())-valued monadic actions as a monoid. If m is some  monad, then Seq m is a monoid where $ does nothing and %  sequences actions via &. JDrops the element at an index from a list. If the index is out of bounds ' then the list is returned unmodified. listReplace old new list replaces all occurrences of old with new in  list. 4Modifies the element at a specific index in a list. Extracts a left value from an '. Extracts a right value from an '.  Transforms the left value of an ', leaving a right value alone. !Transforms the right value of an ', leaving a left value alone.  This is just (#, but looks nicer when used beside . 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. #Executes the monadic function if a + contains a value.  JFinds the first tuple whose first element is true, and returns its second L 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.  ,A in a monad. Executes the actions in the list in order. If any O action returns false then the remaining actions are skipped and the result is J false. Otherwise all actions returned true, and the result is true. An  empty list returns true.  -0 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 Right3 value, it is re-executed with the returned value.  When it returns a Left2 value, the loop stops and the value is returned.      0               0 Safe-Inferred2A 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. NoneA wrapper around  with an 1# instance that considers two nodes I equal iff they contain the same properties (not necessarily in the same J order), and if they contain children (in the same order) whose nodes are  recursively equal. This instance is not on - directly because it is not the only obvious K sense of equality (only comparing properties would be another one), and it's  also potentially expensive. IAn SGF game tree node. Unlike in the SGF spec, we represent a game tree O with nodes uniformly, rather than having the separation between sequences and  nodes. See . !An SGF collection of game trees. !+A node with no properties and no children. "Returns a fresh root  with % set to Goatee and optionally with a  board size set via . #*Searches for a matching property in a node's property list. $5Searches for a matching property in a property list. %+Retrieves the value of a property in a node's property list. &6Retrieves the value of a property in a property list. 'Appends a property to a node's property list. (addChild child parent appends a child node to a node's child list. )addChildAt index child parent! inserts a child node into a node's child L list at the given index, shifting all nodes at or after the given index to , the right. The index must be in the range [0, numberOfChildren]. *=Returns a list of validation errors for the current node, an ' empty list if no errors are detected.  !"#$%&'()*234 !"#$%&'()* !"#$%&'()* !"#$%&'()*234None4+?A pointer to a node in a game tree that also holds information 3 about the current state of the game at that node. -)The cursor for the node above this cursor' s node in 6 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 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. /1The game tree node about which the cursor stores  information. 0/The complete board state for the current node. 5GInternal data structure, only for move application code. Represents a  group of stones. 6The possible results from 7. 83There is already a stone of the specified color on 1 the target point, and overwriting is forbidden. 93Playing the move would result in suicide, which is  forbidden. :2The move was accepted; playing it resulted in the 8 given board with a capture. The specified side gained  the number of points given. ;2The move was accepted; playing it resulted in the  given board without capture. < A structure that configures how 7 should handle moves that are  normally illegal in Go. =If false, suicide will cause 7 to return  9". If true, suicide will kill the 1 friendly group and give points to the opponent. >2If false, playing on an occupied point will cause  7 to return 8 with the 3 color of the stone occupying the point. If true, 7 playing on an occupied point will overwrite the point 7 (the previous stone vanishes), then capture rules are  applied as normal. 1Used by 88 to represent the state of a single point on the board. K Records whether a stone is present, as well as annotations and visibility  properties. 3$Whether this point is a star point. 8KAn object that corresponds to a node in some game tree, and represents the K state of the game at that node, including board position, player turn and ' captures, and also board annotations. :IThe state of individual points on the board. Stored in row-major order.  Point (x, y) can be accessed via  !! y !! x (but prefer  h). ;Whether any of the board's 1s are invisible. This is an < optimization to make it more efficient to set the board to  all visible. <Whether any of the board's 1s are dimmed. This is an F optimization to make it more efficient to clear all dimming from the  board. E2Properties that are specified in game info nodes. ]?Properties that are specified in the root nodes of game trees. b Builds a E with the given ] and no extra data. c:Returns whether a node contains any game info properties. d Converts a E into a list of s that can be used to  reconstruct the E. e+Returns the width of the board, in stones. f,Returns the height of the board, in stones. ? Creates a 83 for an empty board of the given width and height. h Returns the 1 for a coordinate on a board. iMaps a function over each 1 in a 8, 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 ] within the E of a  8. A!Applies a function to update the E of a 8. B Performs necessary updates to a 8 between nodes in the tree.  Clears marks. CJSets all points on a board to be visible (if given true) or invisible (if  given false). D/Resets all points on a board not to be dimmed. E  isStarPoint width height x y Returns whether (x, y)5 is a known star point on a board of the given width  and height. FApplies a property to a 8'. This function covers all properties  that modify 85s, including making moves, adding markup, and so on. G5Applies the transformation function to all of a board's coordinates  referred to by the 6. HUpdates properties of a 8$ given that the player of the given I color has just made a move. Increments the move number and updates the  player turn. IAs an argument to 7(, causes illegal moves to be treated as  errors. JAs an argument to 7$, causes illegal moves to be played  unconditionally. KIf the 62 represents a successful move, then the resulting  8% is returned, otherwise, the default 8 given is  returned. 7JPlaces a stone of a color at a point on a board, and runs move validation M and capturing logic according to the given parameters. Returns whether the , move was successful, and the result if so. LBCapture if there is a liberty-less group of a color at a point on B a board. Removes captured stones from the board and accumulates  points for captured stones. M@Returns a list of the four coordinates that are adjacent to the C given coordinate on the board, excluding coordinates that are out  of bounds. N?Takes a list of coordinates that comprise a group (e.g. a list  returned from O*) and returns the number of liberties the C group has. Does no error checking to ensure that the list refers  to a single or maximal group. O>Expands a single coordinate on a board into a list of all the B coordinates connected to it by some continuous path of stones of # the same color (or empty spaces). jKReturns whether it is legal to place a stone of the given color at a point B on a board. Accepts out-of-bound coordinates and returns false. kIReturns whether it is legal for the current player to place a stone at a H point on a board. Accepts out-of-bound coordinates and returns false. l"Returns a cursor for a root node. rThis is simply  . /. tLReturns the variations to display for a cursor. The returned list contains  the location and color of  and  properties in variation nodes. M Variation nodes are either children of the current node, or siblings of the 7 current node, depending on the variation mode source. v+,-./05PQRS689:;<T=>123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef?ghi@ABCDEUVWXFYGZHIJK[7L\]MNOjklmnopqrstu^_K+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuK]^_`aEFGHIJKLMNOPQRSTUVWXYZ[\bcd89:;<=>?@ABCDef1234567ghijk+,-./0lmnopqrstu9+,-./05PQRS6;:98<T=>12345678 9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef?ghi@ABCDEUVWXFYGZHIJK[7L\]MNOjklmnopqrstu^_ NoneBvA handler for s. It is called with the old - variation mode then the new variation mode. wA handler for s. It is called with the old + property list then the new property list. xA handler for s. MA navigation handler may navigate further, but beware infinite recursion. A C navigation handler must end on the same node on which it started. yA handler for (s. It is called with the old game info  then the new game info. zA handler for s. {CA type of event in the Go monad transformer that can be handled by  executing an action. go# is the type of the type of the Go  monad/transformer. h5 is the type of monad or monadic function which will N be used by Go actions that can trigger the event. For example, a navigation  event is characterized by a * that cannot easily be recovered from the M regular monad state, and comparing before-and-after states would be a pain.  So h for navigation events is  -> go (); a handler takes a  - and returns a Go action to run as a result. |The regular monad for `. }"The regular monad transformer for `. `2A monad (transformer) for navigating and mutating +s, and & remembering previous locations. See } and |. LThe monad supports handlers for events raised during actions it takes, such 5 as navigating through the tree and modifying nodes. ~Returns the current cursor.  Returns the 1 at the given point. =Navigates up the tree. It must be valid to do so, otherwise a is  called. Fires a  after moving. FNavigates down the tree to the child with the given index. The child  must exist. Fires a  after moving. -Navigates up to the root of the tree. Fires  s for each  step. FNavigates up the tree to the node containing game info properties, if 3 any. Returns true if a game info node was found. GPushes the current location in the game tree onto an internal position  stack, such that + is capable of navigating back to the same L position, even if the game tree has been modified (though the old position 0 must still exist in the tree to return to it). IReturns 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  6 off of the stack. This action must be balanced by a . 3Returns the set of properties on the current node. 4Modifies the set of properties on the current node. BThe given function must end on the same node on which it started. DSearches for a property on the current node, returning it if found. HSearches for a valued property on the current node, returning its value  if found. ISets a property on the current node, replacing an existing property with  the same name, if one exists. /Deletes a property from the current node, if it's set. Note that although a  is a q, giving a valued  Property; here will not cause deletion to match on the value of the 7 property. That is, the following code will result in . , because 9 the deletion only cares about the name of the property.  do putProperty $ PL Black  deleteProperty $ PL White  getPropertyValue propertyPL CCalls 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. This L function does not do any validation to check that the resulting tree state  is valid. JCalls 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 / with the property's value marks the  property'?s presence. This function does not do any validation to check ) that the resulting tree state is valid. JMutates the string-valued property attached to the current node according L to the given function. The input string will be empty if the current node 6 either has the property with an empty value, or doesn't have the property. I Returning an empty string removes the property from the node, if it was  set.  Mutates the 6.-valued property attached to the current node 6 according to the given function. Conversion between  CoordList and  [Coord]B is performed automatically. The input list will be empty if the C current node either has the property with an empty value, or doesn't have L 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 > where a present, empty list has different semantics from the , property not being present. In that case,  is better. HMutates the game info for the current path, returning the new info. If I the current node or one of its ancestors has game info properties, then H 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.  Returns the ! at a point on the current node. 5Calls the given function to modify the presence of a  on the  current node. GAdds a child node to the current node at the given index, shifting all K existing children at and after the index to the right. The index must in  the range [0, numberOfChildren] . Fires a  after the  child is added. 6Registers a new event handler for a given event type. 5A single step along a game tree. Either up or down. :Represents a step down to the child with the given index. 8Represents a step up from a child with the given index. bKA path stack is a record of previous places visited in a game tree. It is F encoded a list of paths (steps) to each previous memorized position.  The positions saved in calls to  correspond to entries in the J outer list here, with the first sublist representing the last call. The J sublist contains the steps in order that will trace the path back to the  saved position. c/The internal state of a Go monad transformer. go is the type of & Go monad or transformer (instance of GoMonad). d'The current position in the game tree. eThe current path stack. f Handlers for . g Handlers for . h Handlers for . i Handlers for . j Handlers for . k&A simplified constructor function for c. l0Reverses a step, such that taking a step then it's reverse will leave you  where you started. mTakes a  from a +, returning a new +. nInternal function. Takes a * in the Go monad. Updates the path stack  accordingly. IExecutes a Go monad transformer on a cursor, returning in the underlying G monad a tuple that contains the resulting value and the final cursor. IExecutes a Go monad transformer on a cursor, returning in the underlying % monad the value in the transformer. IExecutes 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. :Runs a Go monad on a cursor and returns the final cursor. oGTakes a step up the game tree, updates the path stack according to the G given function, then fires navigation and game info changed events as  appropriate. pITakes a step down the game tree, updates the path stack according to the G given function, then fires navigation and game info changed events as  appropriate. q Returns the current path stack. rIMaps over a path stack, updating with the given functions all steps that  enter and leave the cursor's current node. KFires all of the handlers for the given event, using the given function to M 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). HAn event corresponding to a child node being added to the current node. EAn event that is fired when the current game info changes, either by O navigating past a node with game info properties, or by modifying the current  game info properties. GAn event that is fired when a single step up or down in a game tree is  made. GAn 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 2 collections (as they have different root nodes). Uvwxyz{stuv|}wx`~5When no node with game info is found, then if false, 6 return to the original node, otherwise finish at the  root node. bcydefghijklmnz{|opqr}~0vwxyz{|}~0}|~{zyxwv,vwxyz{stuv|}wx`~bcydefghijklmnz{|opqr}~ NoneJParses a string in SGF format. Returns an error string if parsing fails. HParses a file in SGF format. Returns an error string if parsing fails.  NoneRenders an SGF  to a string. KRecursively renders an SGF GameTree (as defined in the spec) rooted at the  given node. ERenders a node and its properties without recurring to its children.  !"#$%&'()*+,-./01233456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyyz{|}~~       !!"##$%&&'(()*+,-./012344567899:;<=>??@ABCDEFGHIJKKLMNOPQRSTUVWXYZ[\]^_`abbcdefghijklmnopqrstuvwxy z { | } ~                           1                                <>@F                                                 u     z !"#$%&'$(&)&*+,-./0+1+23456789:;<=>?@ABCDEFGHIJKLMNOPQRST:UVWAXYZ[\]^_`ab c$d e f g h i j k l m n o p q r s t u  v w x  y f z { | } ~              goatee-0.1.0Game.Goatee.Sgf.RendererGame.Goatee.Sgf.TypesGame.Goatee.Sgf.Property.ParserGame.Goatee.Sgf.PropertyGame.Goatee.CommonGame.Goatee.AppGame.Goatee.Sgf.TreeGame.Goatee.Sgf.BoardGame.Goatee.Sgf.MonadGame.Goatee.Sgf.ParserGame.Goatee.Sgf.Renderer.Tree Paths_goatee!Game.Goatee.Sgf.Property.RendererGame.Goatee.Sgf.Property.ValueGame.Goatee.Sgf.Property.BaseGame.Goatee.Sgf.Property.InfoRender runRender rendererOf RulesetTypeRulesetNewZealandRulesetJapanese RulesetIng RulesetAgaRulesetUnknownRuleset KnownRuleset WinReason WinByForfeit WinByTimeWinByResignation WinByScore GameResultGameResultOtherGameResultUnknownGameResultVoidGameResultDraw GameResultWinMark MarkSelectedMarkX MarkTriangle MarkSquare MarkCircle LabelListLineList ArrowListVariationModeSourceShowCurrentVariationsShowChildVariations VariationModevariationModeSourcevariationModeBoardMarkupColorWhiteBlack DoubleValueDouble2Double1UnknownPropertyValuefromUnknownPropertyValue SimpleTextfromSimpleTextTextfromText Stringlike sgfToString stringToSgf RealValue CoordListcoordListSinglescoordListRectsCoordsupportedFormatVersionsdefaultFormatVersionsupportedGameTypesboardSizeDefault boardSizeMin boardSizeMaxcoord1coordscoords'emptyCoordListexpandCoordListbuildCoordListtoText toSimpleTexttoUnknownPropertyValuecnotdefaultVariationModetoVariationModefromVariationMode fromRuleset toRulesetcomposeline colorParsercoordElistParsercoordListParsercoordPairListParser doubleParsergameResultParserlabelListParser moveParser noneParserintegralParser realParser rulesetParsersimpleTextPairParsersimpleTextParser simpleText sizeParser textParsertextunknownPropertyParservariationModeParserPropertyValueType pvtParser pvtRendererpvtRendererPrettyValuedPropertyInfo PropertyInfoValuedDescriptor propertyValuepropertyBuilderSomeDescriptor Descriptor propertyName propertyTypepropertyInheritedpropertyPredicatepropertyValueParserpropertyValueRendererpropertyValueRendererPretty PropertyTypeGeneralPropertyGameInfoProperty RootProperty SetupProperty MovePropertyPropertyUnknownPropertyVWWTWRUSTMSORUROREPWPCPBOTONGNGCEVDTCPBTBRANSZSTGMFFCAAPTRSQSLMALNLBDDCRARTEITDOBMVUCNHOGWGBDMCPLAWAEABWMNKOB 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 propertyVWpropertyUnknownallDescriptors propertyInfodescriptorsByNamedescriptorForNamedescriptorForName' markPropertySeqlistDeleteIndex listReplace listUpdatefromLeft fromRightonLeftonRight andEithersformapTuple whenMaybecondif'andM forIndexM_whileMwhileM'doWhileMapplicationNameapplicationCopyrightapplicationWebsiteapplicationAuthorsNodeWithDeepEqualitynodeWithDeepEqualityNodenodeProperties nodeChildrenCollectionWithDeepEqualitycollectionWithDeepEquality CollectioncollectionTrees emptyNoderootNode findProperty findProperty'findPropertyValuefindPropertyValue' addPropertyaddChild addChildAt validateNodeCursor cursorParentcursorChildIndex cursorNode cursorBoard CoordState coordStar coordStone coordMark coordVisible coordDimmed BoardStateboardCoordStatesboardHasInvisibleboardHasDimmed boardArrows boardLines boardLabelsboardMoveNumberboardPlayerTurnboardBlackCapturesboardWhiteCaptures boardGameInfoGameInfogameInfoRootInfogameInfoBlackNamegameInfoBlackTeamNamegameInfoBlackRankgameInfoWhiteNamegameInfoWhiteTeamNamegameInfoWhiteRankgameInfoRulesetgameInfoBasicTimeSecondsgameInfoOvertimegameInfoResultgameInfoGameNamegameInfoGameCommentgameInfoOpeningComment gameInfoEvent gameInfoRound gameInfoPlacegameInfoDatesPlayedgameInfoSourcegameInfoCopyrightgameInfoAnnotatorNamegameInfoEntererNameRootInfo rootInfoWidthrootInfoHeightrootInfoVariationMode emptyGameInfointernalIsGameInfoNodegameInfoToProperties boardWidth boardHeightrootBoardStateboardCoordStatemapBoardCoords isValidMoveisCurrentValidMove rootCursor cursorRoot cursorChildcursorChildrencursorChildCountcursorChildPlayingAtcursorPropertiescursorModifyNodecursorVariations colorToMoveVariationModeChangedHandlerPropertiesModifiedHandlerNavigationHandlerGameInfoChangedHandlerChildAddedHandlerEventGoMGoT getCursor getCoordStategoUpgoDowngoToRootgoToGameInfoNode pushPosition popPosition dropPosition getPropertiesmodifyProperties getPropertygetPropertyValue putPropertydeletePropertymodifyPropertymodifyPropertyValuemodifyPropertyStringmodifyPropertyCoordsmodifyGameInfomodifyVariationModegetMark modifyMarkonStepGoDownGoUprunGoTevalGoTexecGoTrunGoevalGoexecGofirechildAddedEventgameInfoChangedEventnavigationEventpropertiesModifiedEventvariationModeChangedEvent parseString parseFilerenderCollectioncatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName $fEqCoordListsanitizeSimpleText $fStringlikeUnknownPropertyValue$fStringlikeSimpleText$fStringlikeTextCoordListMonoidbase Data.MonoidMonoidrunCoordListMonoidsinglelistOfnumbercolorcoord gameResultWin winReasonintegralrealtextChar variationMode$fMonoidCoordListMonoid bracketed renderLine renderCoordrenderCoordBracketedrenderCoordPrettyrenderCoordPairPrettyrenderCoordPairrenderCoordPairBracketedrenderShowablerenderStringlikerenderStringlikePrettyrenderColorBracketedrenderColorPrettyrenderCoordElistBracketedrenderCoordElistPrettyrenderCoordListBracketedrenderCoordListPrettyrenderCoordListNonemptyrenderCoordListNonemptyPrettyrenderCoordPairListBracketedrenderCoordPairListPrettyrenderDoubleBracketedrenderDoublePrettyrenderGameResultBracketedrenderGameResultPrettyrenderIntegralBracketedrenderIntegralPrettyrenderLabelListBracketedrenderLabelListPrettyrenderMoveBracketedrenderMovePrettyrenderNoneBracketedrenderNonePrettyrenderRealBracketedrenderRealPrettyrenderRulesetBracketedrenderRulesetPrettyrenderSimpleTextPairBracketedrenderSimpleTextPairPrettyrenderSimpleTextBracketedrenderSimpleTextPrettyrenderSizeBracketedrenderSizePrettyrenderTextBracketedrenderTextPrettyrenderUnknownPropertyBracketedrenderUnknownPropertyPrettyrenderVariationModeBracketedrenderVariationModePrettycolorPvt coordElistPvt coordListPvtcoordPairListPvt doublePvt gameResultPvt integralPvt labelListPvtmovePvtnonePvtrealPvt rulesetPvtsimpleTextPairPvt simpleTextPvtsizePvttextPvtunknownPropertyPvtvariationModePvtvaluedPropertyInfoNamevaluedPropertyInfoTypevaluedPropertyInfoInheritedvaluedPropertyInfoPredicatevaluedPropertyInfoValueTypevaluedPropertyInfoValuevaluedPropertyInfoBuilderpropertyInfoNamepropertyInfoInstancepropertyInfoTypepropertyInfoInherited%$fValuedDescriptorValuedPropertyInfov$fDescriptorValuedPropertyInfo$fDescriptorPropertyInfo$fDescriptorSomeDescriptor$fDescriptorPropertymemptymappendGHC.Base>> Data.EitherEitherfmapLeftRight Data.MaybeMaybeGHC.Listand Control.MonadforM_NothingJust $fMonoidSeqghc-prim GHC.ClassesEqvalidateNodeDuplicates$fEqNodeWithDeepEquality$fEqCollectionWithDeepEqualityApplyMoveGroupApplyMoveResult applyMoveApplyMoveOverwriteErrorApplyMoveSuicideErrorApplyMoveCapture ApplyMoveOkApplyMoveParams allowSuicideallowOverwriteemptyBoardStateupdateRootInfoupdateBoardInfo boardChildsetBoardVisibleclearBoardDimmed isStarPoint applyPropertyupdateCoordStatesupdateBoardForMovestandardGoMoveParamsplayTheDarnMoveGoParamsgetApplyMoveResult maybeCaptureadjacentPointsgetLibertiesOfGroup bucketFillapplyMoveGroupOriginapplyMoveGroupCoordsapplyMoveGroupLiberties isStarPoint' isStarPoint9 isStarPoint13 isStarPoint19applyPropertiesupdateCoordStates'getApplyMoveResult' computeGroupapplyMoveCapture$fShowCoordState$fShowBoardStateMonadGofail PathStackGoState stateCursorstatePathStackstateChildAddedHandlersstateGameInfoChangedHandlersstateNavigationHandlersstatePropertiesModifiedHandlers!stateVariationModeChangedHandlers initialState reverseSteptakeStep takeStepMgoUp'goDown' getPathStackupdatePathStackCurrentNode eventNameeventStateGettereventStateSettergoStategetStateputState modifyState addHandler $fShowEvent $fMonadGoGoT$fMonadWriterwGoT $fMonadIOGoT$fMonadTransGoT $fMonadGoT$fApplicativeGoT $fFunctorGoT collectiongameTreenodepropertyrenderGameTree renderNode