[{"name":"AUF","comment":" Types and helpers to deal with Adjust U Face (AUF), which\nare the moves needed either to adjust the U face to the right\nangle for executing your algorithms for several algorithm sets\nsuch as OLL and PLL, or the last move needed to solve the cube\nfor example after PLL. See\n<https://www.speedsolving.com/wiki/index.php/AUF>\nfor more information\n\n\n# Definition and Constructors\n\n@docs AUF, all\n\n\n# Helpers\n\n@docs toAlgorithm, toString, FromStringError, debugFromStringError, fromString\n\n","unions":[{"name":"AUF","comment":" The 4 different AUFs. U, U', U2, and nothing.\nUse these value constructors together with [@all](#all)\nwhen you need to construct in different ways.\n","args":[],"cases":[["None",[]],["Clockwise",[]],["Halfway",[]],["CounterClockwise",[]]]},{"name":"FromStringError","comment":" Explains an issue that occurred while parsing an AUF\n\n**InvalidAUFAlgorithm**: The algorithm was parsed correctly but was not\neither an empty move or a turn of the U face\n\n**AlgorithmParsingProblem**: The string was not a valid algorithm string\nand the contained [Algorithm.FromStringError](Algorithm#FromStringError)\nhas the problem with the string\n\n","args":[],"cases":[["InvalidAUFAlgorithm",["String.String"]],["AlgorithmParsingError",["Algorithm.FromStringError"]]]}],"aliases":[],"values":[{"name":"all","comment":" A nonempty list containing all the possible aufs.\nCould for example be used to generate a random auf or\ngenerate all the possible versions of an algorithm\n\n    import List.Nonempty\n\n    -- They are all there!\n    List.Nonempty.length all --> 4\n\n    -- Generate a random one\n    List.Nonempty.sample all\n\n    -- Get all versions of a Y perm\n    all\n        |> List.Nonempty.map (Tuple.pair PLL.Y)\n        |> List.Nonempty.map (\\(pll, postAuf) ->\n            List.Nonempty.map\n                (\\preAuf -> (preAuf, pll, postAuf))\n                all\n        )\n\n","type":"List.Nonempty.Nonempty AUF.AUF"},{"name":"debugFromStringError","comment":" Describes the error as a string, and is not recommended\nto be displayed to end-users, but rather to be used in error\nmesages logged for developer's eyes etc.\n\n    case fromString aufString of\n        Ok _ ->\n            doSomethingOnSuccess\n\n        Err error ->\n            logError (debugFromStringError error)\n\n","type":"AUF.FromStringError -> String.String"},{"name":"fromString","comment":" Attempts to parse an algorithmic representation of an AUF\n\n    fromString \"U'\" --> Ok CounterClockwise\n\n    fromString \"\" --> Ok None\n\n    fromString \"U B\"\n    --> Err (InvalidAUFAlgorithm \"U B\")\n\n","type":"String.String -> Result.Result AUF.FromStringError AUF.AUF"},{"name":"toAlgorithm","comment":" Get the algorithm that corresponds to the AUF\n\n    import Algorithm\n\n    toAlgorithm Halfway\n    -->  Algorithm.fromTurnList\n    -->    [ Algorithm.Turn\n    -->        Algorithm.U\n    -->        Algorithm.Halfway\n    -->        Algorithm.Clockwise\n    -->    ]\n\n","type":"AUF.AUF -> Algorithm.Algorithm"},{"name":"toString","comment":" Get an algorithm string representation of the AUF\n\n    toString Halfway --> \"U2\"\n\n","type":"AUF.AUF -> String.String"}],"binops":[]},{"name":"Algorithm","comment":"\n\n\n# Definition\n\n@docs Algorithm, Turn, Turnable, TurnLength, TurnDirection\n\n\n# Constructors\n\n@docs fromTurnList, empty\n\n\n# (De)Serialization\n\n@docs toString, fromString, FromStringError, debugFromStringError\n\n\n# Helpers\n\n@docs inverse, append, reverseAppend\n\n\n# Enumerations\n\n@docs allTurns, allTurnables, allTurnLengths, allTurnDirections\n\n\n# Advanced\n\n@docs toTurnList\n\n","unions":[{"name":"Algorithm","comment":" Any sequence of turns on a 3x3 Rubik's Cube.\nUsually used to describe an\n[algorithm](https://www.speedsolving.com/wiki/index.php/Algorithm)\nused to solve a specific case for speedcubing.\n\nThe notation used is based on:\n<https://www.speedsolving.com/wiki/index.php/Notation>\n\nIt is meant to be used for speedcubing so it includes\noptions such as cube rotations, wide moves and\nthree-quarter turns even if those aren't necessary to\nbe able to solve the cube, but can be important in\ndescribing the fastest way to solve a given case for\na human\n\n","args":[],"cases":[]},{"name":"FromStringError","comment":" The different descriptions of in which way a string is\nnot a valid algorithm string. Note that all these errors\nassume that the string is user input, and so makes some\nopinionated decisions about when and how to error based\non that.\n\nIf you want to programatically create arbitrary algorithms\nyou should use constructors such as\n[fromTurnList](#fromTurnList)\n\nFor an example of how to handle and display these errors to\na user on user input, make sure to check out this\n[full user input example](https://github.com/emilgoldsmith/elm-speedcubing/blob/main/examples/src/AlgorithmFromString.elm)\n\n  - **EmptyAlgorithm**: There were no turns in the string and\n    this does not make sense for user input.\n\n    If you need behaviour like this just allow the user to not\n    input any algorithm at all\n\n  - **InvalidTurnable**: A turnable such as U or x was expected\n    but not found\n\n  - **InvalidTurnLength**: It seems like a turn length such as 2\n    or 3 was attempted to be specified but wasn't valid\n\n  - **RepeatedTurnable**: The same turnable was repeated twice in\n    a row which would never make sense in an algorithm. The correct\n    way to describe this is by combining the two into one such as\n    UU becoming U2, or UU' just not being there at all\n\n  - **TurnWouldWorkWithoutInterruption**: It looks like an otherwise\n    correct turn was specified but a parenthesis, some whitespace\n    or something similar came in the way making it invalid\n\n  - **ApostropheWrongSideOfLength**: It looks like the apostrophe\n    was put on the wrong side of the length, such as U'2 instead\n    of U2' in an otherwise correct turn, just swapping these\n    would make it valid\n\n  - **UnclosedParenthesis**: There is an opening parenthesis that\n    was never closed\n\n  - **UnmatchedClosingParenthesis**: There is a closing parenthesis\n    that doesn't have an opening match\n\n  - **EmptyParentheses**: There is a set of parentheses that aren't\n    enclosing any turns, which does not make sense as parentheses are\n    used to group turns to help memorization and execution\n\n  - **NestedParentheses**: A second set of parentheses were started\n    within a set of parentheses. Nested triggers or other nested grouping\n    hasn't seemed to be a relevant need anywhere in the community\n    so it is not allowed until need has been proven\n\n  - **SpansOverSeveralLines**: An algorithm is not allowed to span over\n    several different lines, the string input should just be a single line\n\n  - **InvalidSymbol**: A symbol was encountered that does not make any\n    sense in an algorithm anywhere.\n\n  - **UnexpectedError**: The parsing code behaved in an unexpected way.\n    This should never happen unless we have a bug in our code. If you get\n    this error in production code just either tell the user that the\n    algorithm wasn't valid without any further explanation or tell them\n    something unexpected happen. The debugInfo key is not helpful to show\n    to users, but only for figuring out how to fix the Elm Package to avoid\n    this happening in the future, and logging a\n    [Github Issue](https://github.com/emilgoldsmith/elm-speedcubing/issues/new)\n    with the debugInfo would be very appreciated\n\n","args":[],"cases":[["EmptyAlgorithm",[]],["InvalidTurnable",["{ inputString : String.String, errorIndex : Basics.Int, invalidTurnable : String.String }"]],["InvalidTurnLength",["{ inputString : String.String, errorIndex : Basics.Int, invalidLength : String.String }"]],["RepeatedTurnable",["{ inputString : String.String, errorIndex : Basics.Int }"]],["WideMoveStylesMixed",["{ inputString : String.String, errorIndex : Basics.Int, invalidWideMove : String.String }"]],["TurnWouldWorkWithoutInterruption",["{ inputString : String.String, interruptionStart : Basics.Int, interruptionEnd : Basics.Int }"]],["ApostropheWrongSideOfLength",["{ inputString : String.String, errorIndex : Basics.Int }"]],["UnclosedParenthesis",["{ inputString : String.String, openParenthesisIndex : Basics.Int }"]],["UnmatchedClosingParenthesis",["{ inputString : String.String, errorIndex : Basics.Int }"]],["EmptyParentheses",["{ inputString : String.String, errorIndex : Basics.Int }"]],["NestedParentheses",["{ inputString : String.String, errorIndex : Basics.Int }"]],["SpansOverSeveralLines",["String.String"]],["InvalidSymbol",["{ inputString : String.String, errorIndex : Basics.Int, symbol : Char.Char }"]],["UnexpectedError",["{ inputString : String.String, errorIndex : Basics.Int, debugInfo : String.String }"]]]},{"name":"Turn","comment":" Describes a single turn, which is rotating any turnable\nin a given direction for a given amount of degrees\n","args":[],"cases":[["Turn",["Algorithm.Turnable","Algorithm.TurnLength","Algorithm.TurnDirection"]]]},{"name":"TurnDirection","comment":" Describes which direction to turn a turnable in a turn\n","args":[],"cases":[["Clockwise",[]],["CounterClockwise",[]]]},{"name":"TurnLength","comment":" Describes how much to turn a turnable in a turn\n","args":[],"cases":[["OneQuarter",[]],["Halfway",[]],["ThreeQuarters",[]]]},{"name":"Turnable","comment":" Describes anything that can be turned on a Rubik's Cube\nsuch as a face, a slice, a rotation of the whole cube or\nseveral slices together also known as a wide move\n","args":[],"cases":[["U",[]],["D",[]],["L",[]],["R",[]],["F",[]],["B",[]],["M",[]],["S",[]],["E",[]],["Uw",[]],["Dw",[]],["Lw",[]],["Rw",[]],["Fw",[]],["Bw",[]],["X",[]],["Y",[]],["Z",[]]]}],"aliases":[],"values":[{"name":"allTurnDirections","comment":" All possible turn directions\n\nCan for example be used if you ever need to list all possible\nturn directions to a user, or if you need to select a turn\ndirection at random\n\n    import List.Nonempty\n\n    List.Nonempty.sample allTurnDirections\n\n    List.Nonempty.length allTurnDirections --> 2\n\n","type":"List.Nonempty.Nonempty Algorithm.TurnDirection"},{"name":"allTurnLengths","comment":" All possible turn lengths\n\nCan for example be used if you ever need to list all possible\nturn lengths to a user, or if you need to select a turn length\nat random\n\n    import List.Nonempty\n\n    List.Nonempty.sample allTurnLengths\n\n    List.Nonempty.length allTurnLengths --> 3\n\n","type":"List.Nonempty.Nonempty Algorithm.TurnLength"},{"name":"allTurnables","comment":" All possible turnables\n\nCan for example be used if you ever need to list all possible\nturnables to a user, or if you need to select a turnable at random\n\n    import List.Nonempty\n\n    List.Nonempty.sample allTurnables\n\n    List.Nonempty.length allTurnables --> 18\n\n","type":"List.Nonempty.Nonempty Algorithm.Turnable"},{"name":"allTurns","comment":" All possible combinations of turnables, lengths and directions\n\nCan for example be used if you ever need to list all possible turns to\na user, or if you need to select a turn at random\n\n    import List.Nonempty\n\n    List.Nonempty.sample allTurns\n\n    List.Nonempty.length allTurns\n    --> List.Nonempty.length allTurnables\n    -->     * List.Nonempty.length allTurnLengths\n    -->     * List.Nonempty.length allTurnDirections\n\n","type":"List.Nonempty.Nonempty Algorithm.Turn"},{"name":"append","comment":" We append the two arguments, so a ++ b\n\n    Result.map2 append (fromString \"U\") (fromString \"B'\")\n    --> fromString \"UB'\"\n\n","type":"Algorithm.Algorithm -> Algorithm.Algorithm -> Algorithm.Algorithm"},{"name":"debugFromStringError","comment":" Describes the error as a string, and is not recommended\nto be displayed to end-users, but rather to be used in error\nmesages logged for developer's eyes etc.\n\n    case fromString algorithmString of\n        Ok _ ->\n            doSomethingOnSuccess\n\n        Err error ->\n            logError (debugFromStringError error)\n\n","type":"Algorithm.FromStringError -> String.String"},{"name":"empty","comment":" An empty algorithm\n","type":"Algorithm.Algorithm"},{"name":"fromString","comment":" Parses user input and either returns the algorithm\ndescribed by the string or a detailed error description of\nwhy it failed\n\n    fromString \"\" --> Err EmptyAlgorithm\n\n    fromString \"U\" --> Ok (fromTurnList [Turn U OneQuarter Clockwise])\n\n","type":"String.String -> Result.Result Algorithm.FromStringError Algorithm.Algorithm"},{"name":"fromTurnList","comment":" Create an Algorithm from a list of turns\n\n    fromTurnList\n        [ Turn U OneQuarter CounterClockwise\n        , Turn B Halfway Clockwise\n        ]\n\n","type":"List.List Algorithm.Turn -> Algorithm.Algorithm"},{"name":"inverse","comment":" Get the inverse of the algorithm.\n\nBy definition this means that if one was to\napply the algorithm followed by its inverse\none would arrive at the same state one started at.\n\n    Result.map inverse <| fromString \"UB'\"\n    --> fromString \"BU'\"\n\n","type":"Algorithm.Algorithm -> Algorithm.Algorithm"},{"name":"reverseAppend","comment":" We append the two algorithms in reverse, so b ++ a\n\n    Result.map2 reverseAppend (fromString \"U\") (fromString \"B'\")\n    --> fromString \"B'U\"\n\n","type":"Algorithm.Algorithm -> Algorithm.Algorithm -> Algorithm.Algorithm"},{"name":"toString","comment":" Display an algorithm in a standard format readable by humans\n\n    fromTurnList\n        [ Turn U Halfway CounterClockwise\n        , Turn F OneQuarter Clockwise\n        ]\n        |> toString\n    --> \"U2' F\"\n\n","type":"Algorithm.Algorithm -> String.String"},{"name":"toTurnList","comment":" You should not need this for by far most use cases.\n\nIt will let you introspect the algorithm which can be useful\nin some advanced usecases, but in general you should avoid this\nand just pass around the algorithm type\n\n","type":"Algorithm.Algorithm -> List.List Algorithm.Turn"}],"binops":[]},{"name":"Cube","comment":" Documentation to come\n\n@docs Cube, applyAlgorithm, solved, viewUBLWithLetters, viewUFRNoLetters, viewUFRWithLetters\n\n","unions":[{"name":"Cube","comment":" Placeholder\n","args":[],"cases":[["Cube",["Internal.Cube.Cube"]]]}],"aliases":[],"values":[{"name":"applyAlgorithm","comment":" Placeholder\n","type":"Algorithm.Algorithm -> Cube.Cube -> Cube.Cube"},{"name":"solved","comment":" Placeholder\n","type":"Cube.Cube"},{"name":"viewUBLWithLetters","comment":" Placeholder\n","type":"List.List (Html.Attribute msg) -> Basics.Int -> Cube.Cube -> Html.Html msg"},{"name":"viewUFRNoLetters","comment":" Placeholder\n","type":"List.List (Html.Attribute msg) -> Basics.Int -> Cube.Cube -> Html.Html msg"},{"name":"viewUFRWithLetters","comment":" Placeholder\n","type":"List.List (Html.Attribute msg) -> Basics.Int -> Cube.Cube -> Html.Html msg"}],"binops":[]},{"name":"Cube.Advanced","comment":" Documentation to come\n\n@docs render\n\n","unions":[],"aliases":[],"values":[{"name":"render","comment":" Placeholder\n","type":"Cube.Cube -> Cube.Advanced.Types.Rendering"}],"binops":[]},{"name":"Cube.Advanced.Types","comment":" Documentation to come\n\n@docs Color, CubieRendering, Rendering\n\n","unions":[{"name":"Color","comment":" Placeholder\n","args":[],"cases":[["UpColor",[]],["DownColor",[]],["FrontColor",[]],["BackColor",[]],["LeftColor",[]],["RightColor",[]],["PlasticColor",[]]]}],"aliases":[{"name":"CubieRendering","comment":" Placeholder\n","args":[],"type":"{ u : Cube.Advanced.Types.Color, d : Cube.Advanced.Types.Color, f : Cube.Advanced.Types.Color, b : Cube.Advanced.Types.Color, l : Cube.Advanced.Types.Color, r : Cube.Advanced.Types.Color }"},{"name":"Rendering","comment":" Placeholder\n","args":[],"type":"{ ufr : Cube.Advanced.Types.CubieRendering, ufl : Cube.Advanced.Types.CubieRendering, ubl : Cube.Advanced.Types.CubieRendering, ubr : Cube.Advanced.Types.CubieRendering, dfr : Cube.Advanced.Types.CubieRendering, dfl : Cube.Advanced.Types.CubieRendering, dbl : Cube.Advanced.Types.CubieRendering, dbr : Cube.Advanced.Types.CubieRendering, uf : Cube.Advanced.Types.CubieRendering, df : Cube.Advanced.Types.CubieRendering, db : Cube.Advanced.Types.CubieRendering, ub : Cube.Advanced.Types.CubieRendering, ur : Cube.Advanced.Types.CubieRendering, ul : Cube.Advanced.Types.CubieRendering, dl : Cube.Advanced.Types.CubieRendering, dr : Cube.Advanced.Types.CubieRendering, fl : Cube.Advanced.Types.CubieRendering, fr : Cube.Advanced.Types.CubieRendering, br : Cube.Advanced.Types.CubieRendering, bl : Cube.Advanced.Types.CubieRendering, u : Cube.Advanced.Types.CubieRendering, d : Cube.Advanced.Types.CubieRendering, f : Cube.Advanced.Types.CubieRendering, b : Cube.Advanced.Types.CubieRendering, l : Cube.Advanced.Types.CubieRendering, r : Cube.Advanced.Types.CubieRendering }"}],"values":[],"binops":[]},{"name":"PLL","comment":" Types and helper functions to work with the Permutate Last\nLayer (PLL) algorithm set, the last step of the CFOP method. See\n<https://www.speedsolving.com/wiki/index.php/PLL>\nfor further information\n\n\n# Definition And Constructors\n\n@docs PLL, all\n\n\n# Helpers\n\n@docs getLetters\n\n\n# Collections\n\n@docs Algorithms, getAlgorithm, referenceAlgorithms\n\n","unions":[{"name":"PLL","comment":" All the cases are represented here. Use the value constructors here\nor [@all](#all) to specify a given case in your code, and pass these to\nany of the helper functions\n","args":[],"cases":[["H",[]],["Ua",[]],["Ub",[]],["Z",[]],["Aa",[]],["Ab",[]],["E",[]],["F",[]],["Ga",[]],["Gb",[]],["Gc",[]],["Gd",[]],["Ja",[]],["Jb",[]],["Na",[]],["Nb",[]],["Ra",[]],["Rb",[]],["T",[]],["V",[]],["Y",[]]]}],"aliases":[{"name":"Algorithms","comment":" A collection of algorithms that solves the respective case\n","args":[],"type":"{ h : Algorithm.Algorithm, ua : Algorithm.Algorithm, ub : Algorithm.Algorithm, z : Algorithm.Algorithm, aa : Algorithm.Algorithm, ab : Algorithm.Algorithm, e : Algorithm.Algorithm, f : Algorithm.Algorithm, ga : Algorithm.Algorithm, gb : Algorithm.Algorithm, gc : Algorithm.Algorithm, gd : Algorithm.Algorithm, ja : Algorithm.Algorithm, jb : Algorithm.Algorithm, na : Algorithm.Algorithm, nb : Algorithm.Algorithm, ra : Algorithm.Algorithm, rb : Algorithm.Algorithm, t : Algorithm.Algorithm, v : Algorithm.Algorithm, y : Algorithm.Algorithm }"}],"values":[{"name":"all","comment":" A non-empty list of all the PLLs. Can for example\nbe used for randomly selecting a pll\n\n    import List.Nonempty\n\n    -- All the PLLs are there!\n    List.Nonempty.length all --> 21\n\n    -- We could for example select a random PLL case\n    -- via this\n    List.Nonempty.sample all\n\n","type":"List.Nonempty.Nonempty PLL.PLL"},{"name":"getAlgorithm","comment":" Get the algorithm for the PLL case from an algorithm collection.\nThis helps avoid any typos or need to write your own case statements\nin order to get the algorithm for a case passed to a function\n\n    getAlgorithm referenceAlgorithms Y\n    --> referenceAlgorithms.y\n\n","type":"PLL.Algorithms -> PLL.PLL -> Algorithm.Algorithm"},{"name":"getLetters","comment":" Generates a string of the identifying letters of the case.\n\nThis could be used either for serialization purposes, or for\nbuilding a string to display the user in some instances.\n\n    -- Format is always first letter capitalized and\n    -- the second one lower case if applicable\n    getLetters Ua --> \"Ua\"\n\n    getLetters H --> \"H\"\n\n","type":"PLL.PLL -> String.String"},{"name":"referenceAlgorithms","comment":" Plls verified to be correct so they can be used to verify user selected plls\nor for displaying a pll case somewhere on the site.\n\nThey have been chosen to be the optimally lowest move count in HTM just for a\nsmall performance boost.\n\nThe example tests below are just meant for an easier\nto read version of all the algorithms that are verified to be correct.\nThey are also tested via elm-verify-examples so the string versions are\ncorrect equivalents to the code below.\n\n    import Algorithm\n\n    -- Edges Only\n\n    Algorithm.fromString \"R2 U2 R U2 R2 U2 R2 U2 R U2 R2\"\n    --> Ok referenceAlgorithms.h\n\n    Algorithm.fromString \"F2 U' (L R') F2 (L' R) U' F2\"\n    --> Ok referenceAlgorithms.ua\n\n    Algorithm.fromString \"F2 U (R' L) F2 (R L') U F2\"\n    --> Ok referenceAlgorithms.ub\n\n    Algorithm.fromString \"R B' R' B F R' F B' R' B R F2\"\n    --> Ok referenceAlgorithms.z\n\n    -- Corners Only\n\n    Algorithm.fromString \"R' F R' B2 R F' R' B2 R2\"\n    --> Ok referenceAlgorithms.aa\n\n    Algorithm.fromString \"R B' R F2 R' B R F2 R2\"\n    --> Ok referenceAlgorithms.ab\n\n    Algorithm.fromString \"D R' D2 F' D L D' F D2 R D' F' L' F\"\n    --> Ok referenceAlgorithms.e\n\n    -- Corners And Edges\n\n    Algorithm.fromString \"L F R' F' L' F' D2 B' L' B D2 F' R F2\"\n    --> Ok referenceAlgorithms.f\n\n    Algorithm.fromString \"F2' D (R' U R' U' R) D' F2 L' U L\"\n    --> Ok referenceAlgorithms.ga\n\n    Algorithm.fromString \"R' U' R B2 D (L' U L U' L) D' B2\"\n    --> Ok referenceAlgorithms.gb\n\n    Algorithm.fromString \"R2' D' F U' F U F' D R2 B U' B'\"\n    --> Ok referenceAlgorithms.gc\n\n    Algorithm.fromString \"R U R' F2 D' (L U' L' U L') D F2\"\n    --> Ok referenceAlgorithms.gd\n\n    Algorithm.fromString \"B2 R' U' R B2 L' D L' D' L2\"\n    --> Ok referenceAlgorithms.ja\n\n    Algorithm.fromString \"B2 (L U L') B2 (R D' R D) R2\"\n    --> Ok referenceAlgorithms.jb\n\n    Algorithm.fromString \"L U' R U2 L' U R' L U' R U2 L' U R'\"\n    --> Ok referenceAlgorithms.na\n\n    Algorithm.fromString \"R' U L' U2 R U' L R' U L' U2 R U' L\"\n    --> Ok referenceAlgorithms.nb\n\n    Algorithm.fromString \"F2 R' F' U' F' U F R F' U2 F U2 F'\"\n    --> Ok referenceAlgorithms.ra\n\n    Algorithm.fromString \"R2 F R U R U' R' F' R U2 R' U2 R\"\n    --> Ok referenceAlgorithms.rb\n\n    Algorithm.fromString \"F2 D R2 U' R2 F2 D' L2 U L2\"\n    --> Ok referenceAlgorithms.t\n\n    Algorithm.fromString \"R' U R' U' B' R' B2 U' B' U B' R B R\"\n    --> Ok referenceAlgorithms.v\n\n    Algorithm.fromString \"F2 D R2 U R2 D' R' U' R F2 R' U R\"\n    --> Ok referenceAlgorithms.y\n\n","type":"PLL.Algorithms"}],"binops":[]}]