diff --git a/doc/source/_exts/yaqlautodoc.py b/doc/source/_exts/yaqlautodoc.py
index bd67e8a..caba402 100644
--- a/doc/source/_exts/yaqlautodoc.py
+++ b/doc/source/_exts/yaqlautodoc.py
@@ -13,12 +13,12 @@
 #    under the License.
 
 import importlib
+import io
 import operator
 import pkgutil
 import traceback
 import types
 
-import six
 from docutils import nodes
 from docutils.parsers import rst
 from docutils import utils
@@ -123,7 +123,7 @@ def write_module_doc(module, output):
         method = getattr(module, name)
         it = write_method_doc(method, output)
         try:
-            name = six.next(it)
+            name = next(it)
             seq.append((name, it))
         except StopIteration:
             pass
@@ -169,7 +169,7 @@ def generate_doc(source):
         package = importlib.import_module(source)
     except ImportError:
         return 'Error: No such module {0}'.format(source)
-    out = six.StringIO()
+    out = io.StringIO()
     try:
         if hasattr(package, '__path__'):
             write_package_doc(package, out)
diff --git a/requirements.txt b/requirements.txt
index 1eb3ff6..b3acf1f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,3 @@
 pbr>=1.8
 python-dateutil>=2.4.2
 ply
-six>=1.9.0
diff --git a/yaql/cli/cli_functions.py b/yaql/cli/cli_functions.py
index b9758c2..95e3eee 100644
--- a/yaql/cli/cli_functions.py
+++ b/yaql/cli/cli_functions.py
@@ -13,16 +13,12 @@
 #    under the License.
 
 import json
-import locale
 import os
 import readline
 import sys
 
-import six
-
-from yaql.language.exceptions import YaqlParsingException
-
 from yaql import __version__ as version
+from yaql.language.exceptions import YaqlParsingException
 from yaql.language import utils
 
 
@@ -46,10 +42,7 @@ def main(context, show_tokens, parser):
     comm = True
     while comm != 'exit':
         try:
-            comm = six.moves.input(PROMPT)
-            if six.PY2:
-                comm = comm.decode(
-                    sys.stdin.encoding or locale.getpreferredencoding(True))
+            comm = input(PROMPT)
         except EOFError:
             return
         if not comm:
diff --git a/yaql/language/contexts.py b/yaql/language/contexts.py
index f412594..27d1a1b 100644
--- a/yaql/language/contexts.py
+++ b/yaql/language/contexts.py
@@ -14,16 +14,13 @@
 
 import abc
 
-import six
-
 from yaql.language import exceptions
 from yaql.language import runner
 from yaql.language import specs
 from yaql.language import utils
 
 
-@six.add_metaclass(abc.ABCMeta)
-class ContextBase(object):
+class ContextBase(metaclass=abc.ABCMeta):
     def __init__(self, parent_context=None, convention=None):
         self._parent_context = parent_context
         self._convention = convention
@@ -95,7 +92,7 @@ class ContextBase(object):
 
     @abc.abstractmethod
     def keys(self):
-        return six.iterkeys({})
+        return {}.keys()
 
 
 class Context(ContextBase):
@@ -115,8 +112,7 @@ class Context(ContextBase):
     def register_function(self, spec, *args, **kwargs):
         exclusive = kwargs.pop('exclusive', False)
 
-        if not isinstance(spec, specs.FunctionDefinition) \
-                and six.callable(spec):
+        if not isinstance(spec, specs.FunctionDefinition) and callable(spec):
             spec = specs.get_function_definition(
                 spec, *args, convention=self._convention, **kwargs)
 
@@ -139,7 +135,7 @@ class Context(ContextBase):
         if predicate is None:
             predicate = lambda x: True  # noqa: E731
         return (
-            set(six.moves.filter(predicate, self._functions.get(name, set()))),
+            set(filter(predicate, self._functions.get(name, set()))),
             name in self._exclusive_funcs
         )
 
@@ -173,12 +169,12 @@ class Context(ContextBase):
     def __contains__(self, item):
         if isinstance(item, specs.FunctionDefinition):
             return item in self._functions.get(item.name, [])
-        if isinstance(item, six.string_types):
+        if isinstance(item, str):
             return self._normalize_name(item) in self._data
         return False
 
     def keys(self):
-        return six.iterkeys(self._data)
+        return self._data.keys()
 
 
 class MultiContext(ContextBase):
@@ -186,9 +182,9 @@ class MultiContext(ContextBase):
         self._context_list = context_list
         if convention is None:
             convention = context_list[0].convention
-        parents = tuple(six.moves.filter(
-            lambda t: t,
-            six.moves.map(lambda t: t.parent, context_list)))
+        parents = tuple(
+            filter(lambda t: t, map(lambda t: t.parent, context_list))
+        )
         if not parents:
             super(MultiContext, self).__init__(None, convention)
         elif len(parents) == 1:
diff --git a/yaql/language/conventions.py b/yaql/language/conventions.py
index 4941dba..b51fc18 100644
--- a/yaql/language/conventions.py
+++ b/yaql/language/conventions.py
@@ -15,11 +15,8 @@
 import abc
 import re
 
-import six
 
-
-@six.add_metaclass(abc.ABCMeta)
-class Convention(object):
+class Convention(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def convert_function_name(self, name):
         pass
diff --git a/yaql/language/expressions.py b/yaql/language/expressions.py
index 64f3c46..9bfcb5c 100644
--- a/yaql/language/expressions.py
+++ b/yaql/language/expressions.py
@@ -14,8 +14,6 @@
 
 import sys
 
-import six
-
 import yaql
 from yaql.language import exceptions
 from yaql.language import utils
@@ -26,7 +24,6 @@ class Expression(object):
         pass
 
 
-@six.python_2_unicode_compatible
 class Function(Expression):
     def __init__(self, name, *args):
         self.name = name
@@ -37,8 +34,7 @@ class Function(Expression):
         return context(self.name, engine, receiver, context)(*self.args)
 
     def __str__(self):
-        return u'{0}({1})'.format(self.name, ', '.join(
-            map(six.text_type, self.args)))
+        return '{0}({1})'.format(self.name, ', '.join(map(str, self.args)))
 
 
 class BinaryOperator(Function):
@@ -81,7 +77,6 @@ class MapExpression(Function):
         self.uses_receiver = False
 
 
-@six.python_2_unicode_compatible
 class GetContextValue(Function):
     def __init__(self, path):
         super(GetContextValue, self).__init__('#get_context_data', path)
@@ -92,16 +87,15 @@ class GetContextValue(Function):
         return self.path.value
 
 
-@six.python_2_unicode_compatible
 class Constant(Expression):
     def __init__(self, value):
         self.value = value
         self.uses_receiver = False
 
     def __str__(self):
-        if isinstance(self.value, six.text_type):
-            return u"'{0}'".format(self.value)
-        return six.text_type(self.value)
+        if isinstance(self.value, str):
+            return "'{0}'".format(self.value)
+        return str(self.value)
 
     def __call__(self, receiver, context, engine):
         return self.value
@@ -111,7 +105,6 @@ class KeywordConstant(Constant):
     pass
 
 
-@six.python_2_unicode_compatible
 class Wrap(Expression):
     def __init__(self, expression):
         self.expr = expression
@@ -124,7 +117,6 @@ class Wrap(Expression):
         return self.expr(receiver, context, engine)
 
 
-@six.python_2_unicode_compatible
 class MappingRuleExpression(Expression):
     def __init__(self, source, destination):
         self.source = source
@@ -140,7 +132,6 @@ class MappingRuleExpression(Expression):
             self.destination(receiver, context, engine))
 
 
-@six.python_2_unicode_compatible
 class Statement(Function):
     def __init__(self, expression, engine):
         self.expression = expression
@@ -155,7 +146,7 @@ class Statement(Function):
         try:
             return super(Statement, self).__call__(receiver, context, engine)
         except exceptions.WrappedException as e:
-            six.reraise(type(e.wrapped), e.wrapped, sys.exc_info()[2])
+            raise e.wrapped.with_traceback(sys.exc_info()[2])
 
     def evaluate(self, data=utils.NO_VALUE, context=None):
         if context is None or context is utils.NO_VALUE:
diff --git a/yaql/language/lexer.py b/yaql/language/lexer.py
index c51473c..6196375 100644
--- a/yaql/language/lexer.py
+++ b/yaql/language/lexer.py
@@ -15,8 +15,6 @@
 import codecs
 import re
 
-import six
-
 from yaql.language import exceptions
 
 
@@ -66,7 +64,7 @@ class Lexer(object):
             'MAPPING',
             'MAP'
         ] + list(self.keywords.values())
-        for op_symbol, op_record in six.iteritems(self._operators_table):
+        for op_symbol, op_record in self._operators_table.items():
             if op_symbol in ('[]', '{}'):
                 continue
             lexem_name = op_record[2]
diff --git a/yaql/language/parser.out b/yaql/language/parser.out
new file mode 100644
index 0000000..290a5d2
--- /dev/null
+++ b/yaql/language/parser.out
@@ -0,0 +1,4757 @@
+Created by PLY version 3.11 (http://www.dabeaz.com/ply)
+
+Grammar
+
+Rule 0     S' -> value
+Rule 1     value -> value OP_B value
+Rule 2     value -> value OP_C value
+Rule 3     value -> value OP_D value
+Rule 4     value -> value OP_E value
+Rule 5     value -> value OP_F value
+Rule 6     value -> value OP_G value
+Rule 7     value -> value OP_H value
+Rule 8     value -> value OP_I value
+Rule 9     value -> value OP_J value
+Rule 10    value -> value OP_K value
+Rule 11    value -> value OP_L value
+Rule 12    value -> value OP_M value
+Rule 13    value -> value OP_N value
+Rule 14    value -> value OP_O value
+Rule 15    value -> value OP_P value
+Rule 16    value -> value OP_Q value
+Rule 17    value -> value OP_S value
+Rule 18    value -> value OP_T value
+Rule 19    value -> value OP_U value
+Rule 20    value -> OP_D value
+Rule 21    value -> OP_E value
+Rule 22    value -> OP_R value
+Rule 23    value -> QUOTED_STRING
+Rule 24    value -> NUMBER
+Rule 25    value -> TRUE
+Rule 26    value -> FALSE
+Rule 27    value -> NULL
+Rule 28    value -> KEYWORD_STRING
+Rule 29    value -> DOLLAR
+Rule 30    value -> ( value )
+Rule 31    args -> arglist
+Rule 32    args -> named_arglist
+Rule 33    args -> arglist , named_arglist
+Rule 34    args -> incomplete_arglist , named_arglist
+Rule 35    args -> <empty>
+Rule 36    value -> value INDEXER args ]
+Rule 37    value -> INDEXER args ]
+Rule 38    value -> MAP args }
+Rule 39    value -> func
+Rule 40    named_arg -> value MAPPING value
+Rule 41    arglist -> value
+Rule 42    arglist -> , arglist
+Rule 43    arglist -> arglist , arglist
+Rule 44    arglist -> incomplete_arglist , arglist
+Rule 45    incomplete_arglist -> arglist ,
+Rule 46    named_arglist -> named_arg
+Rule 47    named_arglist -> named_arglist , named_arg
+Rule 48    func -> FUNC args )
+
+Terminals, with rules where they appear
+
+(                    : 30
+)                    : 30 48
+,                    : 33 34 42 43 44 45 47
+DOLLAR               : 29
+FALSE                : 26
+FUNC                 : 48
+INDEXER              : 36 37
+KEYWORD_STRING       : 28
+MAP                  : 38
+MAPPING              : 40
+NULL                 : 27
+NUMBER               : 24
+OP_B                 : 1
+OP_C                 : 2
+OP_D                 : 3 20
+OP_E                 : 4 21
+OP_F                 : 5
+OP_G                 : 6
+OP_H                 : 7
+OP_I                 : 8
+OP_J                 : 9
+OP_K                 : 10
+OP_L                 : 11
+OP_M                 : 12
+OP_N                 : 13
+OP_O                 : 14
+OP_P                 : 15
+OP_Q                 : 16
+OP_R                 : 22
+OP_S                 : 17
+OP_T                 : 18
+OP_U                 : 19
+QUOTED_STRING        : 23
+TRUE                 : 25
+]                    : 36 37
+error                : 
+}                    : 38
+
+Nonterminals, with rules where they appear
+
+arglist              : 31 33 42 43 43 44 45
+args                 : 36 37 38 48
+func                 : 39
+incomplete_arglist   : 34 44
+named_arg            : 46 47
+named_arglist        : 32 33 34 47
+value                : 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 13 13 14 14 15 15 16 16 17 17 18 18 19 19 20 21 22 30 36 40 40 41 0
+
+Parsing method: LALR
+
+state 0
+
+    (0) S' -> . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 1
+    func                           shift and go to state 15
+
+state 1
+
+    (0) S' -> value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    OP_T            shift and go to state 34
+    OP_U            shift and go to state 35
+    INDEXER         shift and go to state 36
+
+
+state 2
+
+    (20) value -> OP_D . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 37
+    func                           shift and go to state 15
+
+state 3
+
+    (21) value -> OP_E . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 38
+    func                           shift and go to state 15
+
+state 4
+
+    (22) value -> OP_R . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 39
+    func                           shift and go to state 15
+
+state 5
+
+    (23) value -> QUOTED_STRING .
+
+    OP_B            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_C            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_D            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_E            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_F            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_G            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_H            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_I            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_J            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_K            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_L            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_M            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_N            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_O            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_P            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_Q            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_S            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_T            reduce using rule 23 (value -> QUOTED_STRING .)
+    OP_U            reduce using rule 23 (value -> QUOTED_STRING .)
+    INDEXER         reduce using rule 23 (value -> QUOTED_STRING .)
+    $end            reduce using rule 23 (value -> QUOTED_STRING .)
+    )               reduce using rule 23 (value -> QUOTED_STRING .)
+    MAPPING         reduce using rule 23 (value -> QUOTED_STRING .)
+    ,               reduce using rule 23 (value -> QUOTED_STRING .)
+    ]               reduce using rule 23 (value -> QUOTED_STRING .)
+    }               reduce using rule 23 (value -> QUOTED_STRING .)
+
+
+state 6
+
+    (24) value -> NUMBER .
+
+    OP_B            reduce using rule 24 (value -> NUMBER .)
+    OP_C            reduce using rule 24 (value -> NUMBER .)
+    OP_D            reduce using rule 24 (value -> NUMBER .)
+    OP_E            reduce using rule 24 (value -> NUMBER .)
+    OP_F            reduce using rule 24 (value -> NUMBER .)
+    OP_G            reduce using rule 24 (value -> NUMBER .)
+    OP_H            reduce using rule 24 (value -> NUMBER .)
+    OP_I            reduce using rule 24 (value -> NUMBER .)
+    OP_J            reduce using rule 24 (value -> NUMBER .)
+    OP_K            reduce using rule 24 (value -> NUMBER .)
+    OP_L            reduce using rule 24 (value -> NUMBER .)
+    OP_M            reduce using rule 24 (value -> NUMBER .)
+    OP_N            reduce using rule 24 (value -> NUMBER .)
+    OP_O            reduce using rule 24 (value -> NUMBER .)
+    OP_P            reduce using rule 24 (value -> NUMBER .)
+    OP_Q            reduce using rule 24 (value -> NUMBER .)
+    OP_S            reduce using rule 24 (value -> NUMBER .)
+    OP_T            reduce using rule 24 (value -> NUMBER .)
+    OP_U            reduce using rule 24 (value -> NUMBER .)
+    INDEXER         reduce using rule 24 (value -> NUMBER .)
+    $end            reduce using rule 24 (value -> NUMBER .)
+    )               reduce using rule 24 (value -> NUMBER .)
+    MAPPING         reduce using rule 24 (value -> NUMBER .)
+    ,               reduce using rule 24 (value -> NUMBER .)
+    ]               reduce using rule 24 (value -> NUMBER .)
+    }               reduce using rule 24 (value -> NUMBER .)
+
+
+state 7
+
+    (25) value -> TRUE .
+
+    OP_B            reduce using rule 25 (value -> TRUE .)
+    OP_C            reduce using rule 25 (value -> TRUE .)
+    OP_D            reduce using rule 25 (value -> TRUE .)
+    OP_E            reduce using rule 25 (value -> TRUE .)
+    OP_F            reduce using rule 25 (value -> TRUE .)
+    OP_G            reduce using rule 25 (value -> TRUE .)
+    OP_H            reduce using rule 25 (value -> TRUE .)
+    OP_I            reduce using rule 25 (value -> TRUE .)
+    OP_J            reduce using rule 25 (value -> TRUE .)
+    OP_K            reduce using rule 25 (value -> TRUE .)
+    OP_L            reduce using rule 25 (value -> TRUE .)
+    OP_M            reduce using rule 25 (value -> TRUE .)
+    OP_N            reduce using rule 25 (value -> TRUE .)
+    OP_O            reduce using rule 25 (value -> TRUE .)
+    OP_P            reduce using rule 25 (value -> TRUE .)
+    OP_Q            reduce using rule 25 (value -> TRUE .)
+    OP_S            reduce using rule 25 (value -> TRUE .)
+    OP_T            reduce using rule 25 (value -> TRUE .)
+    OP_U            reduce using rule 25 (value -> TRUE .)
+    INDEXER         reduce using rule 25 (value -> TRUE .)
+    $end            reduce using rule 25 (value -> TRUE .)
+    )               reduce using rule 25 (value -> TRUE .)
+    MAPPING         reduce using rule 25 (value -> TRUE .)
+    ,               reduce using rule 25 (value -> TRUE .)
+    ]               reduce using rule 25 (value -> TRUE .)
+    }               reduce using rule 25 (value -> TRUE .)
+
+
+state 8
+
+    (26) value -> FALSE .
+
+    OP_B            reduce using rule 26 (value -> FALSE .)
+    OP_C            reduce using rule 26 (value -> FALSE .)
+    OP_D            reduce using rule 26 (value -> FALSE .)
+    OP_E            reduce using rule 26 (value -> FALSE .)
+    OP_F            reduce using rule 26 (value -> FALSE .)
+    OP_G            reduce using rule 26 (value -> FALSE .)
+    OP_H            reduce using rule 26 (value -> FALSE .)
+    OP_I            reduce using rule 26 (value -> FALSE .)
+    OP_J            reduce using rule 26 (value -> FALSE .)
+    OP_K            reduce using rule 26 (value -> FALSE .)
+    OP_L            reduce using rule 26 (value -> FALSE .)
+    OP_M            reduce using rule 26 (value -> FALSE .)
+    OP_N            reduce using rule 26 (value -> FALSE .)
+    OP_O            reduce using rule 26 (value -> FALSE .)
+    OP_P            reduce using rule 26 (value -> FALSE .)
+    OP_Q            reduce using rule 26 (value -> FALSE .)
+    OP_S            reduce using rule 26 (value -> FALSE .)
+    OP_T            reduce using rule 26 (value -> FALSE .)
+    OP_U            reduce using rule 26 (value -> FALSE .)
+    INDEXER         reduce using rule 26 (value -> FALSE .)
+    $end            reduce using rule 26 (value -> FALSE .)
+    )               reduce using rule 26 (value -> FALSE .)
+    MAPPING         reduce using rule 26 (value -> FALSE .)
+    ,               reduce using rule 26 (value -> FALSE .)
+    ]               reduce using rule 26 (value -> FALSE .)
+    }               reduce using rule 26 (value -> FALSE .)
+
+
+state 9
+
+    (27) value -> NULL .
+
+    OP_B            reduce using rule 27 (value -> NULL .)
+    OP_C            reduce using rule 27 (value -> NULL .)
+    OP_D            reduce using rule 27 (value -> NULL .)
+    OP_E            reduce using rule 27 (value -> NULL .)
+    OP_F            reduce using rule 27 (value -> NULL .)
+    OP_G            reduce using rule 27 (value -> NULL .)
+    OP_H            reduce using rule 27 (value -> NULL .)
+    OP_I            reduce using rule 27 (value -> NULL .)
+    OP_J            reduce using rule 27 (value -> NULL .)
+    OP_K            reduce using rule 27 (value -> NULL .)
+    OP_L            reduce using rule 27 (value -> NULL .)
+    OP_M            reduce using rule 27 (value -> NULL .)
+    OP_N            reduce using rule 27 (value -> NULL .)
+    OP_O            reduce using rule 27 (value -> NULL .)
+    OP_P            reduce using rule 27 (value -> NULL .)
+    OP_Q            reduce using rule 27 (value -> NULL .)
+    OP_S            reduce using rule 27 (value -> NULL .)
+    OP_T            reduce using rule 27 (value -> NULL .)
+    OP_U            reduce using rule 27 (value -> NULL .)
+    INDEXER         reduce using rule 27 (value -> NULL .)
+    $end            reduce using rule 27 (value -> NULL .)
+    )               reduce using rule 27 (value -> NULL .)
+    MAPPING         reduce using rule 27 (value -> NULL .)
+    ,               reduce using rule 27 (value -> NULL .)
+    ]               reduce using rule 27 (value -> NULL .)
+    }               reduce using rule 27 (value -> NULL .)
+
+
+state 10
+
+    (28) value -> KEYWORD_STRING .
+
+    OP_B            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_C            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_D            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_E            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_F            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_G            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_H            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_I            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_J            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_K            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_L            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_M            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_N            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_O            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_P            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_Q            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_S            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_T            reduce using rule 28 (value -> KEYWORD_STRING .)
+    OP_U            reduce using rule 28 (value -> KEYWORD_STRING .)
+    INDEXER         reduce using rule 28 (value -> KEYWORD_STRING .)
+    $end            reduce using rule 28 (value -> KEYWORD_STRING .)
+    )               reduce using rule 28 (value -> KEYWORD_STRING .)
+    MAPPING         reduce using rule 28 (value -> KEYWORD_STRING .)
+    ,               reduce using rule 28 (value -> KEYWORD_STRING .)
+    ]               reduce using rule 28 (value -> KEYWORD_STRING .)
+    }               reduce using rule 28 (value -> KEYWORD_STRING .)
+
+
+state 11
+
+    (29) value -> DOLLAR .
+
+    OP_B            reduce using rule 29 (value -> DOLLAR .)
+    OP_C            reduce using rule 29 (value -> DOLLAR .)
+    OP_D            reduce using rule 29 (value -> DOLLAR .)
+    OP_E            reduce using rule 29 (value -> DOLLAR .)
+    OP_F            reduce using rule 29 (value -> DOLLAR .)
+    OP_G            reduce using rule 29 (value -> DOLLAR .)
+    OP_H            reduce using rule 29 (value -> DOLLAR .)
+    OP_I            reduce using rule 29 (value -> DOLLAR .)
+    OP_J            reduce using rule 29 (value -> DOLLAR .)
+    OP_K            reduce using rule 29 (value -> DOLLAR .)
+    OP_L            reduce using rule 29 (value -> DOLLAR .)
+    OP_M            reduce using rule 29 (value -> DOLLAR .)
+    OP_N            reduce using rule 29 (value -> DOLLAR .)
+    OP_O            reduce using rule 29 (value -> DOLLAR .)
+    OP_P            reduce using rule 29 (value -> DOLLAR .)
+    OP_Q            reduce using rule 29 (value -> DOLLAR .)
+    OP_S            reduce using rule 29 (value -> DOLLAR .)
+    OP_T            reduce using rule 29 (value -> DOLLAR .)
+    OP_U            reduce using rule 29 (value -> DOLLAR .)
+    INDEXER         reduce using rule 29 (value -> DOLLAR .)
+    $end            reduce using rule 29 (value -> DOLLAR .)
+    )               reduce using rule 29 (value -> DOLLAR .)
+    MAPPING         reduce using rule 29 (value -> DOLLAR .)
+    ,               reduce using rule 29 (value -> DOLLAR .)
+    ]               reduce using rule 29 (value -> DOLLAR .)
+    }               reduce using rule 29 (value -> DOLLAR .)
+
+
+state 12
+
+    (30) value -> ( . value )
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 40
+    func                           shift and go to state 15
+
+state 13
+
+    (37) value -> INDEXER . args ]
+    (31) args -> . arglist
+    (32) args -> . named_arglist
+    (33) args -> . arglist , named_arglist
+    (34) args -> . incomplete_arglist , named_arglist
+    (35) args -> .
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (46) named_arglist -> . named_arg
+    (47) named_arglist -> . named_arglist , named_arg
+    (45) incomplete_arglist -> . arglist ,
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (40) named_arg -> . value MAPPING value
+    (48) func -> . FUNC args )
+
+    ]               reduce using rule 35 (args -> .)
+    ,               shift and go to state 44
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    args                           shift and go to state 41
+    arglist                        shift and go to state 42
+    named_arglist                  shift and go to state 43
+    incomplete_arglist             shift and go to state 45
+    value                          shift and go to state 46
+    named_arg                      shift and go to state 47
+    func                           shift and go to state 15
+
+state 14
+
+    (38) value -> MAP . args }
+    (31) args -> . arglist
+    (32) args -> . named_arglist
+    (33) args -> . arglist , named_arglist
+    (34) args -> . incomplete_arglist , named_arglist
+    (35) args -> .
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (46) named_arglist -> . named_arg
+    (47) named_arglist -> . named_arglist , named_arg
+    (45) incomplete_arglist -> . arglist ,
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (40) named_arg -> . value MAPPING value
+    (48) func -> . FUNC args )
+
+    }               reduce using rule 35 (args -> .)
+    ,               shift and go to state 44
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    args                           shift and go to state 48
+    arglist                        shift and go to state 42
+    named_arglist                  shift and go to state 43
+    incomplete_arglist             shift and go to state 45
+    value                          shift and go to state 46
+    named_arg                      shift and go to state 47
+    func                           shift and go to state 15
+
+state 15
+
+    (39) value -> func .
+
+    OP_B            reduce using rule 39 (value -> func .)
+    OP_C            reduce using rule 39 (value -> func .)
+    OP_D            reduce using rule 39 (value -> func .)
+    OP_E            reduce using rule 39 (value -> func .)
+    OP_F            reduce using rule 39 (value -> func .)
+    OP_G            reduce using rule 39 (value -> func .)
+    OP_H            reduce using rule 39 (value -> func .)
+    OP_I            reduce using rule 39 (value -> func .)
+    OP_J            reduce using rule 39 (value -> func .)
+    OP_K            reduce using rule 39 (value -> func .)
+    OP_L            reduce using rule 39 (value -> func .)
+    OP_M            reduce using rule 39 (value -> func .)
+    OP_N            reduce using rule 39 (value -> func .)
+    OP_O            reduce using rule 39 (value -> func .)
+    OP_P            reduce using rule 39 (value -> func .)
+    OP_Q            reduce using rule 39 (value -> func .)
+    OP_S            reduce using rule 39 (value -> func .)
+    OP_T            reduce using rule 39 (value -> func .)
+    OP_U            reduce using rule 39 (value -> func .)
+    INDEXER         reduce using rule 39 (value -> func .)
+    $end            reduce using rule 39 (value -> func .)
+    )               reduce using rule 39 (value -> func .)
+    MAPPING         reduce using rule 39 (value -> func .)
+    ,               reduce using rule 39 (value -> func .)
+    ]               reduce using rule 39 (value -> func .)
+    }               reduce using rule 39 (value -> func .)
+
+
+state 16
+
+    (48) func -> FUNC . args )
+    (31) args -> . arglist
+    (32) args -> . named_arglist
+    (33) args -> . arglist , named_arglist
+    (34) args -> . incomplete_arglist , named_arglist
+    (35) args -> .
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (46) named_arglist -> . named_arg
+    (47) named_arglist -> . named_arglist , named_arg
+    (45) incomplete_arglist -> . arglist ,
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (40) named_arg -> . value MAPPING value
+    (48) func -> . FUNC args )
+
+    )               reduce using rule 35 (args -> .)
+    ,               shift and go to state 44
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    args                           shift and go to state 49
+    arglist                        shift and go to state 42
+    named_arglist                  shift and go to state 43
+    incomplete_arglist             shift and go to state 45
+    value                          shift and go to state 46
+    named_arg                      shift and go to state 47
+    func                           shift and go to state 15
+
+state 17
+
+    (1) value -> value OP_B . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 50
+    func                           shift and go to state 15
+
+state 18
+
+    (2) value -> value OP_C . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 51
+    func                           shift and go to state 15
+
+state 19
+
+    (3) value -> value OP_D . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 52
+    func                           shift and go to state 15
+
+state 20
+
+    (4) value -> value OP_E . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 53
+    func                           shift and go to state 15
+
+state 21
+
+    (5) value -> value OP_F . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 54
+    func                           shift and go to state 15
+
+state 22
+
+    (6) value -> value OP_G . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 55
+    func                           shift and go to state 15
+
+state 23
+
+    (7) value -> value OP_H . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 56
+    func                           shift and go to state 15
+
+state 24
+
+    (8) value -> value OP_I . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 57
+    func                           shift and go to state 15
+
+state 25
+
+    (9) value -> value OP_J . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 58
+    func                           shift and go to state 15
+
+state 26
+
+    (10) value -> value OP_K . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 59
+    func                           shift and go to state 15
+
+state 27
+
+    (11) value -> value OP_L . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 60
+    func                           shift and go to state 15
+
+state 28
+
+    (12) value -> value OP_M . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 61
+    func                           shift and go to state 15
+
+state 29
+
+    (13) value -> value OP_N . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 62
+    func                           shift and go to state 15
+
+state 30
+
+    (14) value -> value OP_O . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 63
+    func                           shift and go to state 15
+
+state 31
+
+    (15) value -> value OP_P . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 64
+    func                           shift and go to state 15
+
+state 32
+
+    (16) value -> value OP_Q . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 65
+    func                           shift and go to state 15
+
+state 33
+
+    (17) value -> value OP_S . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 66
+    func                           shift and go to state 15
+
+state 34
+
+    (18) value -> value OP_T . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 67
+    func                           shift and go to state 15
+
+state 35
+
+    (19) value -> value OP_U . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 68
+    func                           shift and go to state 15
+
+state 36
+
+    (36) value -> value INDEXER . args ]
+    (31) args -> . arglist
+    (32) args -> . named_arglist
+    (33) args -> . arglist , named_arglist
+    (34) args -> . incomplete_arglist , named_arglist
+    (35) args -> .
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (46) named_arglist -> . named_arg
+    (47) named_arglist -> . named_arglist , named_arg
+    (45) incomplete_arglist -> . arglist ,
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (40) named_arg -> . value MAPPING value
+    (48) func -> . FUNC args )
+
+    ]               reduce using rule 35 (args -> .)
+    ,               shift and go to state 44
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 46
+    args                           shift and go to state 69
+    arglist                        shift and go to state 42
+    named_arglist                  shift and go to state 43
+    incomplete_arglist             shift and go to state 45
+    named_arg                      shift and go to state 47
+    func                           shift and go to state 15
+
+state 37
+
+    (20) value -> OP_D value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 20 (value -> OP_D value .)
+    OP_E            reduce using rule 20 (value -> OP_D value .)
+    OP_F            reduce using rule 20 (value -> OP_D value .)
+    OP_G            reduce using rule 20 (value -> OP_D value .)
+    OP_H            reduce using rule 20 (value -> OP_D value .)
+    OP_I            reduce using rule 20 (value -> OP_D value .)
+    OP_J            reduce using rule 20 (value -> OP_D value .)
+    OP_K            reduce using rule 20 (value -> OP_D value .)
+    OP_L            reduce using rule 20 (value -> OP_D value .)
+    OP_M            reduce using rule 20 (value -> OP_D value .)
+    OP_N            reduce using rule 20 (value -> OP_D value .)
+    OP_O            reduce using rule 20 (value -> OP_D value .)
+    OP_P            reduce using rule 20 (value -> OP_D value .)
+    OP_Q            reduce using rule 20 (value -> OP_D value .)
+    OP_S            reduce using rule 20 (value -> OP_D value .)
+    OP_T            reduce using rule 20 (value -> OP_D value .)
+    OP_U            reduce using rule 20 (value -> OP_D value .)
+    $end            reduce using rule 20 (value -> OP_D value .)
+    )               reduce using rule 20 (value -> OP_D value .)
+    MAPPING         reduce using rule 20 (value -> OP_D value .)
+    ,               reduce using rule 20 (value -> OP_D value .)
+    ]               reduce using rule 20 (value -> OP_D value .)
+    }               reduce using rule 20 (value -> OP_D value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 20 (value -> OP_D value .) ]
+  ! OP_C            [ reduce using rule 20 (value -> OP_D value .) ]
+  ! INDEXER         [ reduce using rule 20 (value -> OP_D value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_F            [ shift and go to state 21 ]
+  ! OP_G            [ shift and go to state 22 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 38
+
+    (21) value -> OP_E value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 21 (value -> OP_E value .)
+    OP_E            reduce using rule 21 (value -> OP_E value .)
+    OP_F            reduce using rule 21 (value -> OP_E value .)
+    OP_G            reduce using rule 21 (value -> OP_E value .)
+    OP_H            reduce using rule 21 (value -> OP_E value .)
+    OP_I            reduce using rule 21 (value -> OP_E value .)
+    OP_J            reduce using rule 21 (value -> OP_E value .)
+    OP_K            reduce using rule 21 (value -> OP_E value .)
+    OP_L            reduce using rule 21 (value -> OP_E value .)
+    OP_M            reduce using rule 21 (value -> OP_E value .)
+    OP_N            reduce using rule 21 (value -> OP_E value .)
+    OP_O            reduce using rule 21 (value -> OP_E value .)
+    OP_P            reduce using rule 21 (value -> OP_E value .)
+    OP_Q            reduce using rule 21 (value -> OP_E value .)
+    OP_S            reduce using rule 21 (value -> OP_E value .)
+    OP_T            reduce using rule 21 (value -> OP_E value .)
+    OP_U            reduce using rule 21 (value -> OP_E value .)
+    $end            reduce using rule 21 (value -> OP_E value .)
+    )               reduce using rule 21 (value -> OP_E value .)
+    MAPPING         reduce using rule 21 (value -> OP_E value .)
+    ,               reduce using rule 21 (value -> OP_E value .)
+    ]               reduce using rule 21 (value -> OP_E value .)
+    }               reduce using rule 21 (value -> OP_E value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 21 (value -> OP_E value .) ]
+  ! OP_C            [ reduce using rule 21 (value -> OP_E value .) ]
+  ! INDEXER         [ reduce using rule 21 (value -> OP_E value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_F            [ shift and go to state 21 ]
+  ! OP_G            [ shift and go to state 22 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 39
+
+    (22) value -> OP_R value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_S            reduce using rule 22 (value -> OP_R value .)
+    OP_T            reduce using rule 22 (value -> OP_R value .)
+    OP_U            reduce using rule 22 (value -> OP_R value .)
+    $end            reduce using rule 22 (value -> OP_R value .)
+    )               reduce using rule 22 (value -> OP_R value .)
+    MAPPING         reduce using rule 22 (value -> OP_R value .)
+    ,               reduce using rule 22 (value -> OP_R value .)
+    ]               reduce using rule 22 (value -> OP_R value .)
+    }               reduce using rule 22 (value -> OP_R value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_C            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_D            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_E            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_F            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_G            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_H            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_I            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_J            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_K            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_L            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_M            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_N            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_O            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_P            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_Q            [ reduce using rule 22 (value -> OP_R value .) ]
+  ! INDEXER         [ reduce using rule 22 (value -> OP_R value .) ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 40
+
+    (30) value -> ( value . )
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    )               shift and go to state 70
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    OP_T            shift and go to state 34
+    OP_U            shift and go to state 35
+    INDEXER         shift and go to state 36
+
+
+state 41
+
+    (37) value -> INDEXER args . ]
+
+    ]               shift and go to state 71
+
+
+state 42
+
+    (31) args -> arglist .
+    (33) args -> arglist . , named_arglist
+    (43) arglist -> arglist . , arglist
+    (45) incomplete_arglist -> arglist . ,
+
+    ]               reduce using rule 31 (args -> arglist .)
+    }               reduce using rule 31 (args -> arglist .)
+    )               reduce using rule 31 (args -> arglist .)
+    ,               shift and go to state 72
+
+
+state 43
+
+    (32) args -> named_arglist .
+    (47) named_arglist -> named_arglist . , named_arg
+
+    ]               reduce using rule 32 (args -> named_arglist .)
+    }               reduce using rule 32 (args -> named_arglist .)
+    )               reduce using rule 32 (args -> named_arglist .)
+    ,               shift and go to state 73
+
+
+state 44
+
+    (42) arglist -> , . arglist
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (45) incomplete_arglist -> . arglist ,
+    (48) func -> . FUNC args )
+
+    ,               shift and go to state 44
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    arglist                        shift and go to state 74
+    value                          shift and go to state 75
+    incomplete_arglist             shift and go to state 76
+    func                           shift and go to state 15
+
+state 45
+
+    (34) args -> incomplete_arglist . , named_arglist
+    (44) arglist -> incomplete_arglist . , arglist
+
+    ,               shift and go to state 77
+
+
+state 46
+
+    (41) arglist -> value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+    (40) named_arg -> value . MAPPING value
+
+    ,               reduce using rule 41 (arglist -> value .)
+    ]               reduce using rule 41 (arglist -> value .)
+    }               reduce using rule 41 (arglist -> value .)
+    )               reduce using rule 41 (arglist -> value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    OP_T            shift and go to state 34
+    OP_U            shift and go to state 35
+    INDEXER         shift and go to state 36
+    MAPPING         shift and go to state 78
+
+
+state 47
+
+    (46) named_arglist -> named_arg .
+
+    ,               reduce using rule 46 (named_arglist -> named_arg .)
+    ]               reduce using rule 46 (named_arglist -> named_arg .)
+    }               reduce using rule 46 (named_arglist -> named_arg .)
+    )               reduce using rule 46 (named_arglist -> named_arg .)
+
+
+state 48
+
+    (38) value -> MAP args . }
+
+    }               shift and go to state 79
+
+
+state 49
+
+    (48) func -> FUNC args . )
+
+    )               shift and go to state 80
+
+
+state 50
+
+    (1) value -> value OP_B value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_B            reduce using rule 1 (value -> value OP_B value .)
+    OP_C            reduce using rule 1 (value -> value OP_B value .)
+    OP_D            reduce using rule 1 (value -> value OP_B value .)
+    OP_E            reduce using rule 1 (value -> value OP_B value .)
+    OP_F            reduce using rule 1 (value -> value OP_B value .)
+    OP_G            reduce using rule 1 (value -> value OP_B value .)
+    OP_H            reduce using rule 1 (value -> value OP_B value .)
+    OP_I            reduce using rule 1 (value -> value OP_B value .)
+    OP_J            reduce using rule 1 (value -> value OP_B value .)
+    OP_K            reduce using rule 1 (value -> value OP_B value .)
+    OP_L            reduce using rule 1 (value -> value OP_B value .)
+    OP_M            reduce using rule 1 (value -> value OP_B value .)
+    OP_N            reduce using rule 1 (value -> value OP_B value .)
+    OP_O            reduce using rule 1 (value -> value OP_B value .)
+    OP_P            reduce using rule 1 (value -> value OP_B value .)
+    OP_Q            reduce using rule 1 (value -> value OP_B value .)
+    OP_S            reduce using rule 1 (value -> value OP_B value .)
+    OP_T            reduce using rule 1 (value -> value OP_B value .)
+    OP_U            reduce using rule 1 (value -> value OP_B value .)
+    INDEXER         reduce using rule 1 (value -> value OP_B value .)
+    $end            reduce using rule 1 (value -> value OP_B value .)
+    )               reduce using rule 1 (value -> value OP_B value .)
+    MAPPING         reduce using rule 1 (value -> value OP_B value .)
+    ,               reduce using rule 1 (value -> value OP_B value .)
+    ]               reduce using rule 1 (value -> value OP_B value .)
+    }               reduce using rule 1 (value -> value OP_B value .)
+
+  ! OP_B            [ shift and go to state 17 ]
+  ! OP_C            [ shift and go to state 18 ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_F            [ shift and go to state 21 ]
+  ! OP_G            [ shift and go to state 22 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+  ! INDEXER         [ shift and go to state 36 ]
+
+
+state 51
+
+    (2) value -> value OP_C value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_B            reduce using rule 2 (value -> value OP_C value .)
+    OP_C            reduce using rule 2 (value -> value OP_C value .)
+    OP_D            reduce using rule 2 (value -> value OP_C value .)
+    OP_E            reduce using rule 2 (value -> value OP_C value .)
+    OP_F            reduce using rule 2 (value -> value OP_C value .)
+    OP_G            reduce using rule 2 (value -> value OP_C value .)
+    OP_H            reduce using rule 2 (value -> value OP_C value .)
+    OP_I            reduce using rule 2 (value -> value OP_C value .)
+    OP_J            reduce using rule 2 (value -> value OP_C value .)
+    OP_K            reduce using rule 2 (value -> value OP_C value .)
+    OP_L            reduce using rule 2 (value -> value OP_C value .)
+    OP_M            reduce using rule 2 (value -> value OP_C value .)
+    OP_N            reduce using rule 2 (value -> value OP_C value .)
+    OP_O            reduce using rule 2 (value -> value OP_C value .)
+    OP_P            reduce using rule 2 (value -> value OP_C value .)
+    OP_Q            reduce using rule 2 (value -> value OP_C value .)
+    OP_S            reduce using rule 2 (value -> value OP_C value .)
+    OP_T            reduce using rule 2 (value -> value OP_C value .)
+    OP_U            reduce using rule 2 (value -> value OP_C value .)
+    INDEXER         reduce using rule 2 (value -> value OP_C value .)
+    $end            reduce using rule 2 (value -> value OP_C value .)
+    )               reduce using rule 2 (value -> value OP_C value .)
+    MAPPING         reduce using rule 2 (value -> value OP_C value .)
+    ,               reduce using rule 2 (value -> value OP_C value .)
+    ]               reduce using rule 2 (value -> value OP_C value .)
+    }               reduce using rule 2 (value -> value OP_C value .)
+
+  ! OP_B            [ shift and go to state 17 ]
+  ! OP_C            [ shift and go to state 18 ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_F            [ shift and go to state 21 ]
+  ! OP_G            [ shift and go to state 22 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+  ! INDEXER         [ shift and go to state 36 ]
+
+
+state 52
+
+    (3) value -> value OP_D value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 3 (value -> value OP_D value .)
+    OP_E            reduce using rule 3 (value -> value OP_D value .)
+    OP_K            reduce using rule 3 (value -> value OP_D value .)
+    OP_L            reduce using rule 3 (value -> value OP_D value .)
+    OP_M            reduce using rule 3 (value -> value OP_D value .)
+    OP_N            reduce using rule 3 (value -> value OP_D value .)
+    OP_O            reduce using rule 3 (value -> value OP_D value .)
+    OP_P            reduce using rule 3 (value -> value OP_D value .)
+    OP_Q            reduce using rule 3 (value -> value OP_D value .)
+    OP_S            reduce using rule 3 (value -> value OP_D value .)
+    OP_T            reduce using rule 3 (value -> value OP_D value .)
+    OP_U            reduce using rule 3 (value -> value OP_D value .)
+    $end            reduce using rule 3 (value -> value OP_D value .)
+    )               reduce using rule 3 (value -> value OP_D value .)
+    MAPPING         reduce using rule 3 (value -> value OP_D value .)
+    ,               reduce using rule 3 (value -> value OP_D value .)
+    ]               reduce using rule 3 (value -> value OP_D value .)
+    }               reduce using rule 3 (value -> value OP_D value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 3 (value -> value OP_D value .) ]
+  ! OP_C            [ reduce using rule 3 (value -> value OP_D value .) ]
+  ! OP_F            [ reduce using rule 3 (value -> value OP_D value .) ]
+  ! OP_G            [ reduce using rule 3 (value -> value OP_D value .) ]
+  ! OP_H            [ reduce using rule 3 (value -> value OP_D value .) ]
+  ! OP_I            [ reduce using rule 3 (value -> value OP_D value .) ]
+  ! OP_J            [ reduce using rule 3 (value -> value OP_D value .) ]
+  ! INDEXER         [ reduce using rule 3 (value -> value OP_D value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 53
+
+    (4) value -> value OP_E value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 4 (value -> value OP_E value .)
+    OP_E            reduce using rule 4 (value -> value OP_E value .)
+    OP_K            reduce using rule 4 (value -> value OP_E value .)
+    OP_L            reduce using rule 4 (value -> value OP_E value .)
+    OP_M            reduce using rule 4 (value -> value OP_E value .)
+    OP_N            reduce using rule 4 (value -> value OP_E value .)
+    OP_O            reduce using rule 4 (value -> value OP_E value .)
+    OP_P            reduce using rule 4 (value -> value OP_E value .)
+    OP_Q            reduce using rule 4 (value -> value OP_E value .)
+    OP_S            reduce using rule 4 (value -> value OP_E value .)
+    OP_T            reduce using rule 4 (value -> value OP_E value .)
+    OP_U            reduce using rule 4 (value -> value OP_E value .)
+    $end            reduce using rule 4 (value -> value OP_E value .)
+    )               reduce using rule 4 (value -> value OP_E value .)
+    MAPPING         reduce using rule 4 (value -> value OP_E value .)
+    ,               reduce using rule 4 (value -> value OP_E value .)
+    ]               reduce using rule 4 (value -> value OP_E value .)
+    }               reduce using rule 4 (value -> value OP_E value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 4 (value -> value OP_E value .) ]
+  ! OP_C            [ reduce using rule 4 (value -> value OP_E value .) ]
+  ! OP_F            [ reduce using rule 4 (value -> value OP_E value .) ]
+  ! OP_G            [ reduce using rule 4 (value -> value OP_E value .) ]
+  ! OP_H            [ reduce using rule 4 (value -> value OP_E value .) ]
+  ! OP_I            [ reduce using rule 4 (value -> value OP_E value .) ]
+  ! OP_J            [ reduce using rule 4 (value -> value OP_E value .) ]
+  ! INDEXER         [ reduce using rule 4 (value -> value OP_E value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 54
+
+    (5) value -> value OP_F value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 5 (value -> value OP_F value .)
+    OP_E            reduce using rule 5 (value -> value OP_F value .)
+    OP_F            reduce using rule 5 (value -> value OP_F value .)
+    OP_G            reduce using rule 5 (value -> value OP_F value .)
+    OP_H            reduce using rule 5 (value -> value OP_F value .)
+    OP_I            reduce using rule 5 (value -> value OP_F value .)
+    OP_J            reduce using rule 5 (value -> value OP_F value .)
+    OP_K            reduce using rule 5 (value -> value OP_F value .)
+    OP_L            reduce using rule 5 (value -> value OP_F value .)
+    OP_M            reduce using rule 5 (value -> value OP_F value .)
+    OP_N            reduce using rule 5 (value -> value OP_F value .)
+    OP_O            reduce using rule 5 (value -> value OP_F value .)
+    OP_P            reduce using rule 5 (value -> value OP_F value .)
+    OP_Q            reduce using rule 5 (value -> value OP_F value .)
+    OP_S            reduce using rule 5 (value -> value OP_F value .)
+    OP_T            reduce using rule 5 (value -> value OP_F value .)
+    OP_U            reduce using rule 5 (value -> value OP_F value .)
+    $end            reduce using rule 5 (value -> value OP_F value .)
+    )               reduce using rule 5 (value -> value OP_F value .)
+    MAPPING         reduce using rule 5 (value -> value OP_F value .)
+    ,               reduce using rule 5 (value -> value OP_F value .)
+    ]               reduce using rule 5 (value -> value OP_F value .)
+    }               reduce using rule 5 (value -> value OP_F value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 5 (value -> value OP_F value .) ]
+  ! OP_C            [ reduce using rule 5 (value -> value OP_F value .) ]
+  ! INDEXER         [ reduce using rule 5 (value -> value OP_F value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_F            [ shift and go to state 21 ]
+  ! OP_G            [ shift and go to state 22 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 55
+
+    (6) value -> value OP_G value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 6 (value -> value OP_G value .)
+    OP_E            reduce using rule 6 (value -> value OP_G value .)
+    OP_F            reduce using rule 6 (value -> value OP_G value .)
+    OP_G            reduce using rule 6 (value -> value OP_G value .)
+    OP_H            reduce using rule 6 (value -> value OP_G value .)
+    OP_I            reduce using rule 6 (value -> value OP_G value .)
+    OP_J            reduce using rule 6 (value -> value OP_G value .)
+    OP_K            reduce using rule 6 (value -> value OP_G value .)
+    OP_L            reduce using rule 6 (value -> value OP_G value .)
+    OP_M            reduce using rule 6 (value -> value OP_G value .)
+    OP_N            reduce using rule 6 (value -> value OP_G value .)
+    OP_O            reduce using rule 6 (value -> value OP_G value .)
+    OP_P            reduce using rule 6 (value -> value OP_G value .)
+    OP_Q            reduce using rule 6 (value -> value OP_G value .)
+    OP_S            reduce using rule 6 (value -> value OP_G value .)
+    OP_T            reduce using rule 6 (value -> value OP_G value .)
+    OP_U            reduce using rule 6 (value -> value OP_G value .)
+    $end            reduce using rule 6 (value -> value OP_G value .)
+    )               reduce using rule 6 (value -> value OP_G value .)
+    MAPPING         reduce using rule 6 (value -> value OP_G value .)
+    ,               reduce using rule 6 (value -> value OP_G value .)
+    ]               reduce using rule 6 (value -> value OP_G value .)
+    }               reduce using rule 6 (value -> value OP_G value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 6 (value -> value OP_G value .) ]
+  ! OP_C            [ reduce using rule 6 (value -> value OP_G value .) ]
+  ! INDEXER         [ reduce using rule 6 (value -> value OP_G value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_F            [ shift and go to state 21 ]
+  ! OP_G            [ shift and go to state 22 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 56
+
+    (7) value -> value OP_H value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 7 (value -> value OP_H value .)
+    OP_E            reduce using rule 7 (value -> value OP_H value .)
+    OP_H            reduce using rule 7 (value -> value OP_H value .)
+    OP_I            reduce using rule 7 (value -> value OP_H value .)
+    OP_J            reduce using rule 7 (value -> value OP_H value .)
+    OP_K            reduce using rule 7 (value -> value OP_H value .)
+    OP_L            reduce using rule 7 (value -> value OP_H value .)
+    OP_M            reduce using rule 7 (value -> value OP_H value .)
+    OP_N            reduce using rule 7 (value -> value OP_H value .)
+    OP_O            reduce using rule 7 (value -> value OP_H value .)
+    OP_P            reduce using rule 7 (value -> value OP_H value .)
+    OP_Q            reduce using rule 7 (value -> value OP_H value .)
+    OP_S            reduce using rule 7 (value -> value OP_H value .)
+    OP_T            reduce using rule 7 (value -> value OP_H value .)
+    OP_U            reduce using rule 7 (value -> value OP_H value .)
+    $end            reduce using rule 7 (value -> value OP_H value .)
+    )               reduce using rule 7 (value -> value OP_H value .)
+    MAPPING         reduce using rule 7 (value -> value OP_H value .)
+    ,               reduce using rule 7 (value -> value OP_H value .)
+    ]               reduce using rule 7 (value -> value OP_H value .)
+    }               reduce using rule 7 (value -> value OP_H value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 7 (value -> value OP_H value .) ]
+  ! OP_C            [ reduce using rule 7 (value -> value OP_H value .) ]
+  ! OP_F            [ reduce using rule 7 (value -> value OP_H value .) ]
+  ! OP_G            [ reduce using rule 7 (value -> value OP_H value .) ]
+  ! INDEXER         [ reduce using rule 7 (value -> value OP_H value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 57
+
+    (8) value -> value OP_I value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 8 (value -> value OP_I value .)
+    OP_E            reduce using rule 8 (value -> value OP_I value .)
+    OP_H            reduce using rule 8 (value -> value OP_I value .)
+    OP_I            reduce using rule 8 (value -> value OP_I value .)
+    OP_J            reduce using rule 8 (value -> value OP_I value .)
+    OP_K            reduce using rule 8 (value -> value OP_I value .)
+    OP_L            reduce using rule 8 (value -> value OP_I value .)
+    OP_M            reduce using rule 8 (value -> value OP_I value .)
+    OP_N            reduce using rule 8 (value -> value OP_I value .)
+    OP_O            reduce using rule 8 (value -> value OP_I value .)
+    OP_P            reduce using rule 8 (value -> value OP_I value .)
+    OP_Q            reduce using rule 8 (value -> value OP_I value .)
+    OP_S            reduce using rule 8 (value -> value OP_I value .)
+    OP_T            reduce using rule 8 (value -> value OP_I value .)
+    OP_U            reduce using rule 8 (value -> value OP_I value .)
+    $end            reduce using rule 8 (value -> value OP_I value .)
+    )               reduce using rule 8 (value -> value OP_I value .)
+    MAPPING         reduce using rule 8 (value -> value OP_I value .)
+    ,               reduce using rule 8 (value -> value OP_I value .)
+    ]               reduce using rule 8 (value -> value OP_I value .)
+    }               reduce using rule 8 (value -> value OP_I value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 8 (value -> value OP_I value .) ]
+  ! OP_C            [ reduce using rule 8 (value -> value OP_I value .) ]
+  ! OP_F            [ reduce using rule 8 (value -> value OP_I value .) ]
+  ! OP_G            [ reduce using rule 8 (value -> value OP_I value .) ]
+  ! INDEXER         [ reduce using rule 8 (value -> value OP_I value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 58
+
+    (9) value -> value OP_J value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_D            reduce using rule 9 (value -> value OP_J value .)
+    OP_E            reduce using rule 9 (value -> value OP_J value .)
+    OP_H            reduce using rule 9 (value -> value OP_J value .)
+    OP_I            reduce using rule 9 (value -> value OP_J value .)
+    OP_J            reduce using rule 9 (value -> value OP_J value .)
+    OP_K            reduce using rule 9 (value -> value OP_J value .)
+    OP_L            reduce using rule 9 (value -> value OP_J value .)
+    OP_M            reduce using rule 9 (value -> value OP_J value .)
+    OP_N            reduce using rule 9 (value -> value OP_J value .)
+    OP_O            reduce using rule 9 (value -> value OP_J value .)
+    OP_P            reduce using rule 9 (value -> value OP_J value .)
+    OP_Q            reduce using rule 9 (value -> value OP_J value .)
+    OP_S            reduce using rule 9 (value -> value OP_J value .)
+    OP_T            reduce using rule 9 (value -> value OP_J value .)
+    OP_U            reduce using rule 9 (value -> value OP_J value .)
+    $end            reduce using rule 9 (value -> value OP_J value .)
+    )               reduce using rule 9 (value -> value OP_J value .)
+    MAPPING         reduce using rule 9 (value -> value OP_J value .)
+    ,               reduce using rule 9 (value -> value OP_J value .)
+    ]               reduce using rule 9 (value -> value OP_J value .)
+    }               reduce using rule 9 (value -> value OP_J value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 9 (value -> value OP_J value .) ]
+  ! OP_C            [ reduce using rule 9 (value -> value OP_J value .) ]
+  ! OP_F            [ reduce using rule 9 (value -> value OP_J value .) ]
+  ! OP_G            [ reduce using rule 9 (value -> value OP_J value .) ]
+  ! INDEXER         [ reduce using rule 9 (value -> value OP_J value .) ]
+  ! OP_D            [ shift and go to state 19 ]
+  ! OP_E            [ shift and go to state 20 ]
+  ! OP_H            [ shift and go to state 23 ]
+  ! OP_I            [ shift and go to state 24 ]
+  ! OP_J            [ shift and go to state 25 ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 59
+
+    (10) value -> value OP_K value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_K            reduce using rule 10 (value -> value OP_K value .)
+    OP_L            reduce using rule 10 (value -> value OP_K value .)
+    OP_M            reduce using rule 10 (value -> value OP_K value .)
+    OP_N            reduce using rule 10 (value -> value OP_K value .)
+    OP_O            reduce using rule 10 (value -> value OP_K value .)
+    OP_P            reduce using rule 10 (value -> value OP_K value .)
+    OP_Q            reduce using rule 10 (value -> value OP_K value .)
+    OP_S            reduce using rule 10 (value -> value OP_K value .)
+    OP_T            reduce using rule 10 (value -> value OP_K value .)
+    OP_U            reduce using rule 10 (value -> value OP_K value .)
+    $end            reduce using rule 10 (value -> value OP_K value .)
+    )               reduce using rule 10 (value -> value OP_K value .)
+    MAPPING         reduce using rule 10 (value -> value OP_K value .)
+    ,               reduce using rule 10 (value -> value OP_K value .)
+    ]               reduce using rule 10 (value -> value OP_K value .)
+    }               reduce using rule 10 (value -> value OP_K value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_C            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_D            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_E            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_F            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_G            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_H            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_I            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_J            [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! INDEXER         [ reduce using rule 10 (value -> value OP_K value .) ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 60
+
+    (11) value -> value OP_L value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_K            reduce using rule 11 (value -> value OP_L value .)
+    OP_L            reduce using rule 11 (value -> value OP_L value .)
+    OP_M            reduce using rule 11 (value -> value OP_L value .)
+    OP_N            reduce using rule 11 (value -> value OP_L value .)
+    OP_O            reduce using rule 11 (value -> value OP_L value .)
+    OP_P            reduce using rule 11 (value -> value OP_L value .)
+    OP_Q            reduce using rule 11 (value -> value OP_L value .)
+    OP_S            reduce using rule 11 (value -> value OP_L value .)
+    OP_T            reduce using rule 11 (value -> value OP_L value .)
+    OP_U            reduce using rule 11 (value -> value OP_L value .)
+    $end            reduce using rule 11 (value -> value OP_L value .)
+    )               reduce using rule 11 (value -> value OP_L value .)
+    MAPPING         reduce using rule 11 (value -> value OP_L value .)
+    ,               reduce using rule 11 (value -> value OP_L value .)
+    ]               reduce using rule 11 (value -> value OP_L value .)
+    }               reduce using rule 11 (value -> value OP_L value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_C            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_D            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_E            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_F            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_G            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_H            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_I            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_J            [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! INDEXER         [ reduce using rule 11 (value -> value OP_L value .) ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 61
+
+    (12) value -> value OP_M value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_K            reduce using rule 12 (value -> value OP_M value .)
+    OP_L            reduce using rule 12 (value -> value OP_M value .)
+    OP_M            reduce using rule 12 (value -> value OP_M value .)
+    OP_N            reduce using rule 12 (value -> value OP_M value .)
+    OP_O            reduce using rule 12 (value -> value OP_M value .)
+    OP_P            reduce using rule 12 (value -> value OP_M value .)
+    OP_Q            reduce using rule 12 (value -> value OP_M value .)
+    OP_S            reduce using rule 12 (value -> value OP_M value .)
+    OP_T            reduce using rule 12 (value -> value OP_M value .)
+    OP_U            reduce using rule 12 (value -> value OP_M value .)
+    $end            reduce using rule 12 (value -> value OP_M value .)
+    )               reduce using rule 12 (value -> value OP_M value .)
+    MAPPING         reduce using rule 12 (value -> value OP_M value .)
+    ,               reduce using rule 12 (value -> value OP_M value .)
+    ]               reduce using rule 12 (value -> value OP_M value .)
+    }               reduce using rule 12 (value -> value OP_M value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_C            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_D            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_E            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_F            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_G            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_H            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_I            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_J            [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! INDEXER         [ reduce using rule 12 (value -> value OP_M value .) ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 62
+
+    (13) value -> value OP_N value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_K            reduce using rule 13 (value -> value OP_N value .)
+    OP_L            reduce using rule 13 (value -> value OP_N value .)
+    OP_M            reduce using rule 13 (value -> value OP_N value .)
+    OP_N            reduce using rule 13 (value -> value OP_N value .)
+    OP_O            reduce using rule 13 (value -> value OP_N value .)
+    OP_P            reduce using rule 13 (value -> value OP_N value .)
+    OP_Q            reduce using rule 13 (value -> value OP_N value .)
+    OP_S            reduce using rule 13 (value -> value OP_N value .)
+    OP_T            reduce using rule 13 (value -> value OP_N value .)
+    OP_U            reduce using rule 13 (value -> value OP_N value .)
+    $end            reduce using rule 13 (value -> value OP_N value .)
+    )               reduce using rule 13 (value -> value OP_N value .)
+    MAPPING         reduce using rule 13 (value -> value OP_N value .)
+    ,               reduce using rule 13 (value -> value OP_N value .)
+    ]               reduce using rule 13 (value -> value OP_N value .)
+    }               reduce using rule 13 (value -> value OP_N value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_C            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_D            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_E            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_F            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_G            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_H            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_I            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_J            [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! INDEXER         [ reduce using rule 13 (value -> value OP_N value .) ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 63
+
+    (14) value -> value OP_O value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_K            reduce using rule 14 (value -> value OP_O value .)
+    OP_L            reduce using rule 14 (value -> value OP_O value .)
+    OP_M            reduce using rule 14 (value -> value OP_O value .)
+    OP_N            reduce using rule 14 (value -> value OP_O value .)
+    OP_O            reduce using rule 14 (value -> value OP_O value .)
+    OP_P            reduce using rule 14 (value -> value OP_O value .)
+    OP_Q            reduce using rule 14 (value -> value OP_O value .)
+    OP_S            reduce using rule 14 (value -> value OP_O value .)
+    OP_T            reduce using rule 14 (value -> value OP_O value .)
+    OP_U            reduce using rule 14 (value -> value OP_O value .)
+    $end            reduce using rule 14 (value -> value OP_O value .)
+    )               reduce using rule 14 (value -> value OP_O value .)
+    MAPPING         reduce using rule 14 (value -> value OP_O value .)
+    ,               reduce using rule 14 (value -> value OP_O value .)
+    ]               reduce using rule 14 (value -> value OP_O value .)
+    }               reduce using rule 14 (value -> value OP_O value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_C            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_D            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_E            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_F            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_G            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_H            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_I            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_J            [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! INDEXER         [ reduce using rule 14 (value -> value OP_O value .) ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 64
+
+    (15) value -> value OP_P value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_K            reduce using rule 15 (value -> value OP_P value .)
+    OP_L            reduce using rule 15 (value -> value OP_P value .)
+    OP_M            reduce using rule 15 (value -> value OP_P value .)
+    OP_N            reduce using rule 15 (value -> value OP_P value .)
+    OP_O            reduce using rule 15 (value -> value OP_P value .)
+    OP_P            reduce using rule 15 (value -> value OP_P value .)
+    OP_Q            reduce using rule 15 (value -> value OP_P value .)
+    OP_S            reduce using rule 15 (value -> value OP_P value .)
+    OP_T            reduce using rule 15 (value -> value OP_P value .)
+    OP_U            reduce using rule 15 (value -> value OP_P value .)
+    $end            reduce using rule 15 (value -> value OP_P value .)
+    )               reduce using rule 15 (value -> value OP_P value .)
+    MAPPING         reduce using rule 15 (value -> value OP_P value .)
+    ,               reduce using rule 15 (value -> value OP_P value .)
+    ]               reduce using rule 15 (value -> value OP_P value .)
+    }               reduce using rule 15 (value -> value OP_P value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_C            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_D            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_E            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_F            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_G            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_H            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_I            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_J            [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! INDEXER         [ reduce using rule 15 (value -> value OP_P value .) ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 65
+
+    (16) value -> value OP_Q value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_K            reduce using rule 16 (value -> value OP_Q value .)
+    OP_L            reduce using rule 16 (value -> value OP_Q value .)
+    OP_M            reduce using rule 16 (value -> value OP_Q value .)
+    OP_N            reduce using rule 16 (value -> value OP_Q value .)
+    OP_O            reduce using rule 16 (value -> value OP_Q value .)
+    OP_P            reduce using rule 16 (value -> value OP_Q value .)
+    OP_Q            reduce using rule 16 (value -> value OP_Q value .)
+    OP_S            reduce using rule 16 (value -> value OP_Q value .)
+    OP_T            reduce using rule 16 (value -> value OP_Q value .)
+    OP_U            reduce using rule 16 (value -> value OP_Q value .)
+    $end            reduce using rule 16 (value -> value OP_Q value .)
+    )               reduce using rule 16 (value -> value OP_Q value .)
+    MAPPING         reduce using rule 16 (value -> value OP_Q value .)
+    ,               reduce using rule 16 (value -> value OP_Q value .)
+    ]               reduce using rule 16 (value -> value OP_Q value .)
+    }               reduce using rule 16 (value -> value OP_Q value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_C            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_D            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_E            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_F            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_G            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_H            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_I            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_J            [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! INDEXER         [ reduce using rule 16 (value -> value OP_Q value .) ]
+  ! OP_K            [ shift and go to state 26 ]
+  ! OP_L            [ shift and go to state 27 ]
+  ! OP_M            [ shift and go to state 28 ]
+  ! OP_N            [ shift and go to state 29 ]
+  ! OP_O            [ shift and go to state 30 ]
+  ! OP_P            [ shift and go to state 31 ]
+  ! OP_Q            [ shift and go to state 32 ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 66
+
+    (17) value -> value OP_S value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_S            reduce using rule 17 (value -> value OP_S value .)
+    OP_T            reduce using rule 17 (value -> value OP_S value .)
+    OP_U            reduce using rule 17 (value -> value OP_S value .)
+    $end            reduce using rule 17 (value -> value OP_S value .)
+    )               reduce using rule 17 (value -> value OP_S value .)
+    MAPPING         reduce using rule 17 (value -> value OP_S value .)
+    ,               reduce using rule 17 (value -> value OP_S value .)
+    ]               reduce using rule 17 (value -> value OP_S value .)
+    }               reduce using rule 17 (value -> value OP_S value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_C            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_D            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_E            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_F            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_G            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_H            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_I            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_J            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_K            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_L            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_M            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_N            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_O            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_P            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_Q            [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! INDEXER         [ reduce using rule 17 (value -> value OP_S value .) ]
+  ! OP_S            [ shift and go to state 33 ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 67
+
+    (18) value -> value OP_T value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    OP_T            reduce using rule 18 (value -> value OP_T value .)
+    OP_U            reduce using rule 18 (value -> value OP_T value .)
+    $end            reduce using rule 18 (value -> value OP_T value .)
+    )               reduce using rule 18 (value -> value OP_T value .)
+    MAPPING         reduce using rule 18 (value -> value OP_T value .)
+    ,               reduce using rule 18 (value -> value OP_T value .)
+    ]               reduce using rule 18 (value -> value OP_T value .)
+    }               reduce using rule 18 (value -> value OP_T value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_C            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_D            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_E            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_F            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_G            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_H            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_I            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_J            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_K            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_L            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_M            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_N            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_O            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_P            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_Q            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_S            [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! INDEXER         [ reduce using rule 18 (value -> value OP_T value .) ]
+  ! OP_T            [ shift and go to state 34 ]
+  ! OP_U            [ shift and go to state 35 ]
+
+
+state 68
+
+    (19) value -> value OP_U value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    $end            reduce using rule 19 (value -> value OP_U value .)
+    )               reduce using rule 19 (value -> value OP_U value .)
+    MAPPING         reduce using rule 19 (value -> value OP_U value .)
+    ,               reduce using rule 19 (value -> value OP_U value .)
+    ]               reduce using rule 19 (value -> value OP_U value .)
+    }               reduce using rule 19 (value -> value OP_U value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    OP_T            shift and go to state 34
+    OP_U            shift and go to state 35
+    INDEXER         shift and go to state 36
+
+  ! OP_B            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_C            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_D            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_E            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_F            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_G            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_H            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_I            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_J            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_K            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_L            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_M            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_N            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_O            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_P            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_Q            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_S            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_T            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! OP_U            [ reduce using rule 19 (value -> value OP_U value .) ]
+  ! INDEXER         [ reduce using rule 19 (value -> value OP_U value .) ]
+
+
+state 69
+
+    (36) value -> value INDEXER args . ]
+
+    ]               shift and go to state 81
+
+
+state 70
+
+    (30) value -> ( value ) .
+
+    OP_B            reduce using rule 30 (value -> ( value ) .)
+    OP_C            reduce using rule 30 (value -> ( value ) .)
+    OP_D            reduce using rule 30 (value -> ( value ) .)
+    OP_E            reduce using rule 30 (value -> ( value ) .)
+    OP_F            reduce using rule 30 (value -> ( value ) .)
+    OP_G            reduce using rule 30 (value -> ( value ) .)
+    OP_H            reduce using rule 30 (value -> ( value ) .)
+    OP_I            reduce using rule 30 (value -> ( value ) .)
+    OP_J            reduce using rule 30 (value -> ( value ) .)
+    OP_K            reduce using rule 30 (value -> ( value ) .)
+    OP_L            reduce using rule 30 (value -> ( value ) .)
+    OP_M            reduce using rule 30 (value -> ( value ) .)
+    OP_N            reduce using rule 30 (value -> ( value ) .)
+    OP_O            reduce using rule 30 (value -> ( value ) .)
+    OP_P            reduce using rule 30 (value -> ( value ) .)
+    OP_Q            reduce using rule 30 (value -> ( value ) .)
+    OP_S            reduce using rule 30 (value -> ( value ) .)
+    OP_T            reduce using rule 30 (value -> ( value ) .)
+    OP_U            reduce using rule 30 (value -> ( value ) .)
+    INDEXER         reduce using rule 30 (value -> ( value ) .)
+    $end            reduce using rule 30 (value -> ( value ) .)
+    )               reduce using rule 30 (value -> ( value ) .)
+    MAPPING         reduce using rule 30 (value -> ( value ) .)
+    ,               reduce using rule 30 (value -> ( value ) .)
+    ]               reduce using rule 30 (value -> ( value ) .)
+    }               reduce using rule 30 (value -> ( value ) .)
+
+
+state 71
+
+    (37) value -> INDEXER args ] .
+
+    OP_B            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_C            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_D            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_E            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_F            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_G            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_H            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_I            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_J            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_K            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_L            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_M            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_N            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_O            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_P            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_Q            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_S            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_T            reduce using rule 37 (value -> INDEXER args ] .)
+    OP_U            reduce using rule 37 (value -> INDEXER args ] .)
+    INDEXER         reduce using rule 37 (value -> INDEXER args ] .)
+    $end            reduce using rule 37 (value -> INDEXER args ] .)
+    )               reduce using rule 37 (value -> INDEXER args ] .)
+    MAPPING         reduce using rule 37 (value -> INDEXER args ] .)
+    ,               reduce using rule 37 (value -> INDEXER args ] .)
+    ]               reduce using rule 37 (value -> INDEXER args ] .)
+    }               reduce using rule 37 (value -> INDEXER args ] .)
+
+
+state 72
+
+    (33) args -> arglist , . named_arglist
+    (43) arglist -> arglist , . arglist
+    (45) incomplete_arglist -> arglist , .
+    (46) named_arglist -> . named_arg
+    (47) named_arglist -> . named_arglist , named_arg
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (40) named_arg -> . value MAPPING value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (45) incomplete_arglist -> . arglist ,
+    (48) func -> . FUNC args )
+
+    ,               reduce using rule 45 (incomplete_arglist -> arglist , .)
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+  ! ,               [ shift and go to state 44 ]
+
+    arglist                        shift and go to state 82
+    named_arglist                  shift and go to state 83
+    named_arg                      shift and go to state 47
+    value                          shift and go to state 84
+    incomplete_arglist             shift and go to state 76
+    func                           shift and go to state 15
+
+state 73
+
+    (47) named_arglist -> named_arglist , . named_arg
+    (40) named_arg -> . value MAPPING value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    named_arg                      shift and go to state 85
+    value                          shift and go to state 86
+    func                           shift and go to state 15
+
+state 74
+
+    (42) arglist -> , arglist .
+    (43) arglist -> arglist . , arglist
+    (45) incomplete_arglist -> arglist . ,
+
+    ,               reduce using rule 42 (arglist -> , arglist .)
+    ]               reduce using rule 42 (arglist -> , arglist .)
+    }               reduce using rule 42 (arglist -> , arglist .)
+    )               reduce using rule 42 (arglist -> , arglist .)
+
+  ! ,               [ shift and go to state 87 ]
+
+
+state 75
+
+    (41) arglist -> value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    ,               reduce using rule 41 (arglist -> value .)
+    ]               reduce using rule 41 (arglist -> value .)
+    }               reduce using rule 41 (arglist -> value .)
+    )               reduce using rule 41 (arglist -> value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    OP_T            shift and go to state 34
+    OP_U            shift and go to state 35
+    INDEXER         shift and go to state 36
+
+
+state 76
+
+    (44) arglist -> incomplete_arglist . , arglist
+
+    ,               shift and go to state 88
+
+
+state 77
+
+    (34) args -> incomplete_arglist , . named_arglist
+    (44) arglist -> incomplete_arglist , . arglist
+    (46) named_arglist -> . named_arg
+    (47) named_arglist -> . named_arglist , named_arg
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (40) named_arg -> . value MAPPING value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (45) incomplete_arglist -> . arglist ,
+    (48) func -> . FUNC args )
+
+    ,               shift and go to state 44
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    incomplete_arglist             shift and go to state 76
+    named_arglist                  shift and go to state 89
+    arglist                        shift and go to state 90
+    named_arg                      shift and go to state 47
+    value                          shift and go to state 84
+    func                           shift and go to state 15
+
+state 78
+
+    (40) named_arg -> value MAPPING . value
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (48) func -> . FUNC args )
+
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    value                          shift and go to state 91
+    func                           shift and go to state 15
+
+state 79
+
+    (38) value -> MAP args } .
+
+    OP_B            reduce using rule 38 (value -> MAP args } .)
+    OP_C            reduce using rule 38 (value -> MAP args } .)
+    OP_D            reduce using rule 38 (value -> MAP args } .)
+    OP_E            reduce using rule 38 (value -> MAP args } .)
+    OP_F            reduce using rule 38 (value -> MAP args } .)
+    OP_G            reduce using rule 38 (value -> MAP args } .)
+    OP_H            reduce using rule 38 (value -> MAP args } .)
+    OP_I            reduce using rule 38 (value -> MAP args } .)
+    OP_J            reduce using rule 38 (value -> MAP args } .)
+    OP_K            reduce using rule 38 (value -> MAP args } .)
+    OP_L            reduce using rule 38 (value -> MAP args } .)
+    OP_M            reduce using rule 38 (value -> MAP args } .)
+    OP_N            reduce using rule 38 (value -> MAP args } .)
+    OP_O            reduce using rule 38 (value -> MAP args } .)
+    OP_P            reduce using rule 38 (value -> MAP args } .)
+    OP_Q            reduce using rule 38 (value -> MAP args } .)
+    OP_S            reduce using rule 38 (value -> MAP args } .)
+    OP_T            reduce using rule 38 (value -> MAP args } .)
+    OP_U            reduce using rule 38 (value -> MAP args } .)
+    INDEXER         reduce using rule 38 (value -> MAP args } .)
+    $end            reduce using rule 38 (value -> MAP args } .)
+    )               reduce using rule 38 (value -> MAP args } .)
+    MAPPING         reduce using rule 38 (value -> MAP args } .)
+    ,               reduce using rule 38 (value -> MAP args } .)
+    ]               reduce using rule 38 (value -> MAP args } .)
+    }               reduce using rule 38 (value -> MAP args } .)
+
+
+state 80
+
+    (48) func -> FUNC args ) .
+
+    OP_B            reduce using rule 48 (func -> FUNC args ) .)
+    OP_C            reduce using rule 48 (func -> FUNC args ) .)
+    OP_D            reduce using rule 48 (func -> FUNC args ) .)
+    OP_E            reduce using rule 48 (func -> FUNC args ) .)
+    OP_F            reduce using rule 48 (func -> FUNC args ) .)
+    OP_G            reduce using rule 48 (func -> FUNC args ) .)
+    OP_H            reduce using rule 48 (func -> FUNC args ) .)
+    OP_I            reduce using rule 48 (func -> FUNC args ) .)
+    OP_J            reduce using rule 48 (func -> FUNC args ) .)
+    OP_K            reduce using rule 48 (func -> FUNC args ) .)
+    OP_L            reduce using rule 48 (func -> FUNC args ) .)
+    OP_M            reduce using rule 48 (func -> FUNC args ) .)
+    OP_N            reduce using rule 48 (func -> FUNC args ) .)
+    OP_O            reduce using rule 48 (func -> FUNC args ) .)
+    OP_P            reduce using rule 48 (func -> FUNC args ) .)
+    OP_Q            reduce using rule 48 (func -> FUNC args ) .)
+    OP_S            reduce using rule 48 (func -> FUNC args ) .)
+    OP_T            reduce using rule 48 (func -> FUNC args ) .)
+    OP_U            reduce using rule 48 (func -> FUNC args ) .)
+    INDEXER         reduce using rule 48 (func -> FUNC args ) .)
+    $end            reduce using rule 48 (func -> FUNC args ) .)
+    )               reduce using rule 48 (func -> FUNC args ) .)
+    MAPPING         reduce using rule 48 (func -> FUNC args ) .)
+    ,               reduce using rule 48 (func -> FUNC args ) .)
+    ]               reduce using rule 48 (func -> FUNC args ) .)
+    }               reduce using rule 48 (func -> FUNC args ) .)
+
+
+state 81
+
+    (36) value -> value INDEXER args ] .
+
+    OP_B            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_C            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_D            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_E            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_F            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_G            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_H            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_I            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_J            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_K            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_L            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_M            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_N            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_O            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_P            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_Q            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_S            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_T            reduce using rule 36 (value -> value INDEXER args ] .)
+    OP_U            reduce using rule 36 (value -> value INDEXER args ] .)
+    INDEXER         reduce using rule 36 (value -> value INDEXER args ] .)
+    $end            reduce using rule 36 (value -> value INDEXER args ] .)
+    )               reduce using rule 36 (value -> value INDEXER args ] .)
+    MAPPING         reduce using rule 36 (value -> value INDEXER args ] .)
+    ,               reduce using rule 36 (value -> value INDEXER args ] .)
+    ]               reduce using rule 36 (value -> value INDEXER args ] .)
+    }               reduce using rule 36 (value -> value INDEXER args ] .)
+
+
+state 82
+
+    (43) arglist -> arglist , arglist .
+    (43) arglist -> arglist . , arglist
+    (45) incomplete_arglist -> arglist . ,
+
+    ,               reduce using rule 43 (arglist -> arglist , arglist .)
+    ]               reduce using rule 43 (arglist -> arglist , arglist .)
+    }               reduce using rule 43 (arglist -> arglist , arglist .)
+    )               reduce using rule 43 (arglist -> arglist , arglist .)
+
+  ! ,               [ shift and go to state 87 ]
+
+
+state 83
+
+    (33) args -> arglist , named_arglist .
+    (47) named_arglist -> named_arglist . , named_arg
+
+    ]               reduce using rule 33 (args -> arglist , named_arglist .)
+    }               reduce using rule 33 (args -> arglist , named_arglist .)
+    )               reduce using rule 33 (args -> arglist , named_arglist .)
+    ,               shift and go to state 73
+
+
+state 84
+
+    (41) arglist -> value .
+    (40) named_arg -> value . MAPPING value
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    ,               reduce using rule 41 (arglist -> value .)
+    ]               reduce using rule 41 (arglist -> value .)
+    }               reduce using rule 41 (arglist -> value .)
+    )               reduce using rule 41 (arglist -> value .)
+    MAPPING         shift and go to state 78
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    OP_T            shift and go to state 34
+    OP_U            shift and go to state 35
+    INDEXER         shift and go to state 36
+
+
+state 85
+
+    (47) named_arglist -> named_arglist , named_arg .
+
+    ,               reduce using rule 47 (named_arglist -> named_arglist , named_arg .)
+    ]               reduce using rule 47 (named_arglist -> named_arglist , named_arg .)
+    }               reduce using rule 47 (named_arglist -> named_arglist , named_arg .)
+    )               reduce using rule 47 (named_arglist -> named_arglist , named_arg .)
+
+
+state 86
+
+    (40) named_arg -> value . MAPPING value
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    MAPPING         shift and go to state 78
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    OP_T            shift and go to state 34
+    OP_U            shift and go to state 35
+    INDEXER         shift and go to state 36
+
+
+state 87
+
+    (43) arglist -> arglist , . arglist
+    (45) incomplete_arglist -> arglist , .
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (45) incomplete_arglist -> . arglist ,
+    (48) func -> . FUNC args )
+
+    ,               reduce using rule 45 (incomplete_arglist -> arglist , .)
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+  ! ,               [ shift and go to state 44 ]
+
+    arglist                        shift and go to state 82
+    value                          shift and go to state 75
+    incomplete_arglist             shift and go to state 76
+    func                           shift and go to state 15
+
+state 88
+
+    (44) arglist -> incomplete_arglist , . arglist
+    (41) arglist -> . value
+    (42) arglist -> . , arglist
+    (43) arglist -> . arglist , arglist
+    (44) arglist -> . incomplete_arglist , arglist
+    (1) value -> . value OP_B value
+    (2) value -> . value OP_C value
+    (3) value -> . value OP_D value
+    (4) value -> . value OP_E value
+    (5) value -> . value OP_F value
+    (6) value -> . value OP_G value
+    (7) value -> . value OP_H value
+    (8) value -> . value OP_I value
+    (9) value -> . value OP_J value
+    (10) value -> . value OP_K value
+    (11) value -> . value OP_L value
+    (12) value -> . value OP_M value
+    (13) value -> . value OP_N value
+    (14) value -> . value OP_O value
+    (15) value -> . value OP_P value
+    (16) value -> . value OP_Q value
+    (17) value -> . value OP_S value
+    (18) value -> . value OP_T value
+    (19) value -> . value OP_U value
+    (20) value -> . OP_D value
+    (21) value -> . OP_E value
+    (22) value -> . OP_R value
+    (23) value -> . QUOTED_STRING
+    (24) value -> . NUMBER
+    (25) value -> . TRUE
+    (26) value -> . FALSE
+    (27) value -> . NULL
+    (28) value -> . KEYWORD_STRING
+    (29) value -> . DOLLAR
+    (30) value -> . ( value )
+    (36) value -> . value INDEXER args ]
+    (37) value -> . INDEXER args ]
+    (38) value -> . MAP args }
+    (39) value -> . func
+    (45) incomplete_arglist -> . arglist ,
+    (48) func -> . FUNC args )
+
+    ,               shift and go to state 44
+    OP_D            shift and go to state 2
+    OP_E            shift and go to state 3
+    OP_R            shift and go to state 4
+    QUOTED_STRING   shift and go to state 5
+    NUMBER          shift and go to state 6
+    TRUE            shift and go to state 7
+    FALSE           shift and go to state 8
+    NULL            shift and go to state 9
+    KEYWORD_STRING  shift and go to state 10
+    DOLLAR          shift and go to state 11
+    (               shift and go to state 12
+    INDEXER         shift and go to state 13
+    MAP             shift and go to state 14
+    FUNC            shift and go to state 16
+
+    incomplete_arglist             shift and go to state 76
+    arglist                        shift and go to state 90
+    value                          shift and go to state 75
+    func                           shift and go to state 15
+
+state 89
+
+    (34) args -> incomplete_arglist , named_arglist .
+    (47) named_arglist -> named_arglist . , named_arg
+
+    ]               reduce using rule 34 (args -> incomplete_arglist , named_arglist .)
+    }               reduce using rule 34 (args -> incomplete_arglist , named_arglist .)
+    )               reduce using rule 34 (args -> incomplete_arglist , named_arglist .)
+    ,               shift and go to state 73
+
+
+state 90
+
+    (44) arglist -> incomplete_arglist , arglist .
+    (43) arglist -> arglist . , arglist
+    (45) incomplete_arglist -> arglist . ,
+
+    ,               reduce using rule 44 (arglist -> incomplete_arglist , arglist .)
+    ]               reduce using rule 44 (arglist -> incomplete_arglist , arglist .)
+    }               reduce using rule 44 (arglist -> incomplete_arglist , arglist .)
+    )               reduce using rule 44 (arglist -> incomplete_arglist , arglist .)
+
+  ! ,               [ shift and go to state 87 ]
+
+
+state 91
+
+    (40) named_arg -> value MAPPING value .
+    (1) value -> value . OP_B value
+    (2) value -> value . OP_C value
+    (3) value -> value . OP_D value
+    (4) value -> value . OP_E value
+    (5) value -> value . OP_F value
+    (6) value -> value . OP_G value
+    (7) value -> value . OP_H value
+    (8) value -> value . OP_I value
+    (9) value -> value . OP_J value
+    (10) value -> value . OP_K value
+    (11) value -> value . OP_L value
+    (12) value -> value . OP_M value
+    (13) value -> value . OP_N value
+    (14) value -> value . OP_O value
+    (15) value -> value . OP_P value
+    (16) value -> value . OP_Q value
+    (17) value -> value . OP_S value
+    (18) value -> value . OP_T value
+    (19) value -> value . OP_U value
+    (36) value -> value . INDEXER args ]
+
+    ,               reduce using rule 40 (named_arg -> value MAPPING value .)
+    ]               reduce using rule 40 (named_arg -> value MAPPING value .)
+    }               reduce using rule 40 (named_arg -> value MAPPING value .)
+    )               reduce using rule 40 (named_arg -> value MAPPING value .)
+    OP_B            shift and go to state 17
+    OP_C            shift and go to state 18
+    OP_D            shift and go to state 19
+    OP_E            shift and go to state 20
+    OP_F            shift and go to state 21
+    OP_G            shift and go to state 22
+    OP_H            shift and go to state 23
+    OP_I            shift and go to state 24
+    OP_J            shift and go to state 25
+    OP_K            shift and go to state 26
+    OP_L            shift and go to state 27
+    OP_M            shift and go to state 28
+    OP_N            shift and go to state 29
+    OP_O            shift and go to state 30
+    OP_P            shift and go to state 31
+    OP_Q            shift and go to state 32
+    OP_S            shift and go to state 33
+    OP_T            shift and go to state 34
+    OP_U            shift and go to state 35
+    INDEXER         shift and go to state 36
+
diff --git a/yaql/language/parser.py b/yaql/language/parser.py
index d7dfb1a..a8b1988 100644
--- a/yaql/language/parser.py
+++ b/yaql/language/parser.py
@@ -12,7 +12,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import six
+import types
 
 from yaql.language import exceptions
 from yaql.language import expressions
@@ -71,9 +71,9 @@ class Parser(object):
                 p[0] = expressions.UnaryOperator(p[2], p[1], alias)
 
         p_binary.__doc__ = binary_doc
-        self.p_binary = six.create_bound_method(p_binary, self)
+        self.p_binary = types.MethodType(p_binary, self)
         p_unary.__doc__ = unary_doc
-        self.p_unary = six.create_bound_method(p_unary, self)
+        self.p_unary = types.MethodType(p_unary, self)
 
         precedence = []
         for i in range(1, len(precedence_dict) + 1):
@@ -98,7 +98,7 @@ class Parser(object):
             p[0] = expressions.Function('#call', p[1], *arg)
 
         if engine.allow_delegates:
-            self.p_value_call = six.create_bound_method(p_value_call, self)
+            self.p_value_call = types.MethodType(p_value_call, self)
 
     @staticmethod
     def p_value_to_const(p):
diff --git a/yaql/language/runner.py b/yaql/language/runner.py
index 6324543..8ea31e7 100644
--- a/yaql/language/runner.py
+++ b/yaql/language/runner.py
@@ -16,8 +16,6 @@
 
 import sys
 
-import six
-
 from yaql.language import exceptions
 from yaql.language import expressions
 from yaql.language import utils
@@ -54,9 +52,7 @@ def call(name, context, args, kwargs, engine, receiver=utils.NO_VALUE,
             utils.limit_memory_usage(engine, (1, result))
             return result
         except StopIteration as e:
-            six.reraise(
-                exceptions.WrappedException,
-                exceptions.WrappedException(e),
+            raise exceptions.WrappedException(e).with_traceback(
                 sys.exc_info()[2])
 
 
@@ -95,7 +91,7 @@ def choose_overload(name, candidates, engine, receiver, context, args, kwargs):
             for i, pos_arg in enumerate(pos):
                 if isinstance(pos_arg.value_type, yaqltypes.LazyParameterType):
                     lazy.add(i)
-            for key, value in six.iteritems(kwd):
+            for key, value in kwd.items():
                 if isinstance(value.value_type, yaqltypes.LazyParameterType):
                     lazy.add(key)
             if lazy_params is None:
@@ -117,7 +113,7 @@ def choose_overload(name, candidates, engine, receiver, context, args, kwargs):
     )
 
     args = tuple(arg_evaluator(i, arg) for i, arg in enumerate(args))
-    for key, value in six.iteritems(kwargs):
+    for key, value in kwargs.items():
         kwargs[key] = arg_evaluator(key, value)
 
     delegate = None
@@ -147,7 +143,7 @@ def choose_overload(name, candidates, engine, receiver, context, args, kwargs):
 def translate_args(without_kwargs, args, kwargs):
     if without_kwargs:
         if len(kwargs) > 0:
-            raise exceptions.ArgumentException(six.next(iter(kwargs)))
+            raise exceptions.ArgumentException(next(iter(kwargs)))
         return args, {}
     pos_args = []
     kw_args = {}
@@ -161,7 +157,7 @@ def translate_args(without_kwargs, args, kwargs):
             kw_args[param_name] = t.destination
         else:
             pos_args.append(t)
-    for key, value in six.iteritems(kwargs):
+    for key, value in kwargs.items():
         if key in kw_args:
             raise exceptions.MappingTranslationException()
         else:
@@ -174,13 +170,13 @@ def _is_specialization_of(mapping1, mapping2):
     args_mapping2, kwargs_mapping2 = mapping2
     res = False
 
-    for a1, a2 in six.moves.zip(args_mapping1, args_mapping2):
+    for a1, a2 in zip(args_mapping1, args_mapping2):
         if a2.value_type.is_specialization_of(a1.value_type):
             return False
         elif a1.value_type.is_specialization_of(a2.value_type):
             res = True
 
-    for key, a1 in six.iteritems(kwargs_mapping1):
+    for key, a1 in kwargs_mapping1.items():
         a2 = kwargs_mapping2[key]
         if a2.value_type.is_specialization_of(a1.value_type):
             return False
diff --git a/yaql/language/specs.py b/yaql/language/specs.py
index 8802cb3..e898074 100644
--- a/yaql/language/specs.py
+++ b/yaql/language/specs.py
@@ -14,8 +14,6 @@
 
 import inspect
 
-import six
-
 from yaql.language import exceptions
 from yaql.language import utils
 from yaql.language import yaqltypes
@@ -66,9 +64,7 @@ class FunctionDefinition(object):
         return func
 
     def clone(self):
-        parameters = dict(
-            (key, p.clone())
-            for key, p in six.iteritems(self.parameters))
+        parameters = {key: p.clone() for key, p in self.parameters.items()}
 
         res = FunctionDefinition(
             self.name, self.payload, parameters, self.doc,
@@ -79,12 +75,12 @@ class FunctionDefinition(object):
         fd = self.clone()
         keys_to_remove = set()
 
-        for k, v in six.iteritems(fd.parameters):
+        for k, v in fd.parameters.items():
             if not isinstance(v.value_type, yaqltypes.HiddenParameterType):
                 continue
             keys_to_remove.add(k)
             if v.position is not None:
-                for v2 in six.itervalues(fd.parameters):
+                for v2 in fd.parameters.values():
                     if v2.position is not None and v2.position > v.position:
                         v2.position -= 1
         for key in keys_to_remove:
@@ -101,67 +97,38 @@ class FunctionDefinition(object):
             self.parameters[name.name] = name
             return name
 
-        if six.PY2:
-            spec = inspect.getargspec(self.payload)
-            if isinstance(name, int):
-                if 0 <= name < len(spec.args):
-                    name = spec.args[name]
-                elif name == len(spec.args) and spec.varargs is not None:
-                    name = spec.varargs
-                else:
-                    raise IndexError('argument position is out of range')
-
-            arg_name = name
-            if name == spec.keywords:
-                position = None
-                arg_name = '**'
-            elif name == spec.varargs:
-                position = len(spec.args)
-                arg_name = '*'
-            elif name not in spec.args:
-                raise exceptions.NoParameterFoundException(
-                    function_name=self.name or self.payload.__name__,
-                    param_name=name)
+        spec = inspect.getfullargspec(self.payload)
+        if isinstance(name, int):
+            if 0 <= name < len(spec.args):
+                name = spec.args[name]
+            elif name == len(spec.args) and spec.varargs is not None:
+                name = spec.varargs
             else:
-                position = spec.args.index(name)
-            default = NO_DEFAULT
-            if spec.defaults is not None and name in spec.args:
-                index = spec.args.index(name) - len(spec.args)
-                if index >= -len(spec.defaults):
-                    default = spec.defaults[index]
+                raise IndexError('argument position is out of range')
+
+        arg_name = name
+        if name == spec.varkw:
+            position = None
+            arg_name = '**'
+        elif name == spec.varargs:
+            position = len(spec.args)
+            arg_name = '*'
+        elif name in spec.kwonlyargs:
+            position = None
+        elif name not in spec.args:
+            raise exceptions.NoParameterFoundException(
+                function_name=self.name or self.payload.__name__,
+                param_name=name)
         else:
-            spec = inspect.getfullargspec(self.payload)
-            if isinstance(name, int):
-                if 0 <= name < len(spec.args):
-                    name = spec.args[name]
-                elif name == len(spec.args) and spec.varargs is not None:
-                    name = spec.varargs
-                else:
-                    raise IndexError('argument position is out of range')
+            position = spec.args.index(name)
 
-            arg_name = name
-            if name == spec.varkw:
-                position = None
-                arg_name = '**'
-            elif name == spec.varargs:
-                position = len(spec.args)
-                arg_name = '*'
-            elif name in spec.kwonlyargs:
-                position = None
-            elif name not in spec.args:
-                raise exceptions.NoParameterFoundException(
-                    function_name=self.name or self.payload.__name__,
-                    param_name=name)
-            else:
-                position = spec.args.index(name)
-
-            default = NO_DEFAULT
-            if spec.defaults is not None and name in spec.args:
-                index = spec.args.index(name) - len(spec.args)
-                if index >= -len(spec.defaults):
-                    default = spec.defaults[index]
-            elif spec.kwonlydefaults is not None:
-                default = spec.kwonlydefaults.get(name, NO_DEFAULT)
+        default = NO_DEFAULT
+        if spec.defaults is not None and name in spec.args:
+            index = spec.args.index(name) - len(spec.args)
+            if index >= -len(spec.defaults):
+                default = spec.defaults[index]
+        elif spec.kwonlydefaults is not None:
+            default = spec.kwonlydefaults.get(name, NO_DEFAULT)
 
         if arg_name in self.parameters and not overwrite:
             raise exceptions.DuplicateParameterDecoratorException(
@@ -191,7 +158,7 @@ class FunctionDefinition(object):
     def insert_parameter(self, name, value_type=None, nullable=None,
                          alias=None, overwrite=False):
         pd = self.set_parameter(name, value_type, nullable, alias, overwrite)
-        for p in six.itervalues(self.parameters):
+        for p in self.parameters.values():
             if p is pd:
                 continue
             if p.position is not None and p.position >= pd.position:
@@ -205,13 +172,13 @@ class FunctionDefinition(object):
         positional_fix_table = max_dst_positional_args * [0]
         keyword_args = {}
 
-        for p in six.itervalues(self.parameters):
+        for p in self.parameters.values():
             if p.position is not None and isinstance(
                     p.value_type, yaqltypes.HiddenParameterType):
                 for index in range(p.position + 1, len(positional_fix_table)):
                     positional_fix_table[index] += 1
 
-        for key, p in six.iteritems(self.parameters):
+        for key, p in self.parameters.items():
             arg_name = p.alias or p.name
             if p.position is not None and key != '*':
                 arg_position = p.position - positional_fix_table[p.position]
@@ -242,7 +209,7 @@ class FunctionDefinition(object):
         if len(kwargs) > 0:
             if '**' in self.parameters:
                 argdef = self.parameters['**']
-                for key in six.iterkeys(kwargs):
+                for key in kwargs:
                     keyword_args[key] = argdef
             else:
                 return None
@@ -255,7 +222,7 @@ class FunctionDefinition(object):
                 value = positional_args[i].default
             if not positional_args[i].value_type.check(value, context, engine):
                 return None
-        for kwd in six.iterkeys(kwargs):
+        for kwd in kwargs:
             if not keyword_args[kwd].value_type.check(
                     kwargs[kwd], context, engine):
                 return None
@@ -278,7 +245,7 @@ class FunctionDefinition(object):
         kwargs = kwargs.copy()
         kwargs = dict(kwargs)
         positional = 0
-        for arg_name, p in six.iteritems(self.parameters):
+        for arg_name, p in self.parameters.items():
             if p.position is not None and arg_name != '*':
                 positional += 1
 
@@ -286,13 +253,13 @@ class FunctionDefinition(object):
         positional_fix_table = positional * [0]
         keyword_args = {}
 
-        for p in six.itervalues(self.parameters):
+        for p in self.parameters.values():
             if p.position is not None and isinstance(
                     p.value_type, yaqltypes.HiddenParameterType):
                 for index in range(p.position + 1, positional):
                     positional_fix_table[index] += 1
 
-        for key, p in six.iteritems(self.parameters):
+        for key, p in self.parameters.items():
             arg_name = p.alias or p.name
             if p.position is not None and key != '*':
                 if isinstance(p.value_type, yaqltypes.HiddenParameterType):
@@ -332,7 +299,7 @@ class FunctionDefinition(object):
         if len(kwargs) > 0:
             if '**' in self.parameters:
                 argdef = self.parameters['**']
-                for key, value in six.iteritems(kwargs):
+                for key, value in kwargs.items():
                     keyword_args[key] = checked(value, argdef)
             else:
                 raise exceptions.ArgumentException('**')
@@ -343,7 +310,7 @@ class FunctionDefinition(object):
                 *tuple(map(lambda t: t(new_context),
                            positional_args)),
                 **dict(map(lambda t: (t[0], t[1](new_context)),
-                           six.iteritems(keyword_args)))
+                           keyword_args.items()))
             )
             return result
 
@@ -352,7 +319,7 @@ class FunctionDefinition(object):
     def is_valid_method(self):
         min_position = len(self.parameters)
         min_arg = None
-        for p in six.itervalues(self.parameters):
+        for p in self.parameters.values():
             if p.position is not None and p.position < min_position and \
                     not isinstance(p.value_type,
                                    yaqltypes.HiddenParameterType):
@@ -407,24 +374,14 @@ def get_function_definition(func, name=None, function=None, method=None,
     if parameter_type_func is None:
         parameter_type_func = _infer_parameter_type
     fd = _get_function_definition(func).clone()
-    if six.PY2:
-        spec = inspect.getargspec(func)
-        for arg in spec.args:
-            if arg not in fd.parameters:
-                fd.set_parameter(arg, parameter_type_func(arg))
-        if spec.varargs and '*' not in fd.parameters:
-            fd.set_parameter(spec.varargs, parameter_type_func(spec.varargs))
-        if spec.keywords and '**' not in fd.parameters:
-            fd.set_parameter(spec.keywords, parameter_type_func(spec.keywords))
-    else:
-        spec = inspect.getfullargspec(func)
-        for arg in spec.args + spec.kwonlyargs:
-            if arg not in fd.parameters:
-                fd.set_parameter(arg, parameter_type_func(arg))
-        if spec.varargs and '*' not in fd.parameters:
-            fd.set_parameter(spec.varargs, parameter_type_func(spec.varargs))
-        if spec.varkw and '**' not in fd.parameters:
-            fd.set_parameter(spec.varkw, parameter_type_func(spec.varkw))
+    spec = inspect.getfullargspec(func)
+    for arg in spec.args + spec.kwonlyargs:
+        if arg not in fd.parameters:
+            fd.set_parameter(arg, parameter_type_func(arg))
+    if spec.varargs and '*' not in fd.parameters:
+        fd.set_parameter(spec.varargs, parameter_type_func(spec.varargs))
+    if spec.varkw and '**' not in fd.parameters:
+        fd.set_parameter(spec.varkw, parameter_type_func(spec.varkw))
 
     if name is not None:
         fd.name = name
@@ -438,7 +395,7 @@ def get_function_definition(func, name=None, function=None, method=None,
     if method is not None:
         fd.is_method = method
     if convention:
-        for p in six.itervalues(fd.parameters):
+        for p in fd.parameters.values():
             if p.alias is None:
                 p.alias = convert_parameter_name(p.name, convention)
     return fd
diff --git a/yaql/language/utils.py b/yaql/language/utils.py
index d761216..97ad8d9 100644
--- a/yaql/language/utils.py
+++ b/yaql/language/utils.py
@@ -16,8 +16,6 @@ import collections
 import re
 import sys
 
-import six
-
 from yaql.language import exceptions
 from yaql.language import lexer
 
@@ -38,13 +36,15 @@ def is_iterator(obj):
 
 
 def is_iterable(obj):
-    return isinstance(obj, collections.Iterable) and not isinstance(
-        obj, six.string_types + (MappingType,))
+    return (
+        isinstance(obj, collections.Iterable) and
+        not isinstance(obj, (str, MappingType))
+    )
 
 
 def is_sequence(obj):
     return isinstance(obj, collections.Sequence) and not isinstance(
-        obj, six.string_types)
+        obj, str)
 
 
 def is_mutable(obj):
@@ -67,17 +67,17 @@ QueueType = collections.deque
 def convert_input_data(obj, rec=None):
     if rec is None:
         rec = convert_input_data
-    if isinstance(obj, six.string_types):
-        return obj if isinstance(obj, six.text_type) else six.text_type(obj)
+    if isinstance(obj, str):
+        return obj if isinstance(obj, str) else str(obj)
     elif isinstance(obj, SequenceType):
         return tuple(rec(t, rec) for t in obj)
     elif isinstance(obj, MappingType):
         return FrozenDict((rec(key, rec), rec(value, rec))
-                          for key, value in six.iteritems(obj))
+                          for key, value in obj.items())
     elif isinstance(obj, MutableSetType):
         return frozenset(rec(t, rec) for t in obj)
     elif isinstance(obj, IterableType):
-        return six.moves.map(lambda v: rec(v, rec), obj)
+        return map(lambda v: rec(v, rec), obj)
     else:
         return obj
 
@@ -87,7 +87,7 @@ def convert_output_data(obj, limit_func, engine, rec=None):
         rec = convert_output_data
     if isinstance(obj, collections.Mapping):
         result = {}
-        for key, value in limit_func(six.iteritems(obj)):
+        for key, value in limit_func(obj.items()):
             result[rec(key, limit_func, engine, rec)] = rec(
                 value, limit_func, engine, rec)
         return result
@@ -139,7 +139,7 @@ class FrozenDict(collections.Mapping):
     def __hash__(self):
         if self._hash is None:
             self._hash = 0
-            for pair in six.iteritems(self):
+            for pair in self.items():
                 self._hash ^= hash(pair)
         return self._hash
 
@@ -153,7 +153,7 @@ def memorize(collection, engine):
 
     yielded = []
 
-    class RememberingIterator(six.Iterator):
+    class RememberingIterator:
         def __init__(self):
             self.seq = iter(collection)
             self.index = 0
diff --git a/yaql/language/yaqltypes.py b/yaql/language/yaqltypes.py
index 13e0e7a..14a7301 100644
--- a/yaql/language/yaqltypes.py
+++ b/yaql/language/yaqltypes.py
@@ -17,7 +17,6 @@ import collections
 import datetime
 
 from dateutil import tz
-import six
 
 from yaql.language import exceptions
 from yaql.language import expressions
@@ -25,8 +24,7 @@ from yaql.language import utils
 from yaql import yaql_interface
 
 
-@six.add_metaclass(abc.ABCMeta)
-class HiddenParameterType(object):
+class HiddenParameterType(metaclass=abc.ABCMeta):
     __slots__ = tuple()
 
     # noinspection PyMethodMayBeStatic,PyUnusedLocal
@@ -34,13 +32,11 @@ class HiddenParameterType(object):
         return True
 
 
-@six.add_metaclass(abc.ABCMeta)
-class LazyParameterType(object):
+class LazyParameterType(metaclass=abc.ABCMeta):
     __slots__ = tuple()
 
 
-@six.add_metaclass(abc.ABCMeta)
-class SmartType(object):
+class SmartType(metaclass=abc.ABCMeta):
     __slots__ = ('nullable',)
 
     def __init__(self, nullable):
@@ -149,13 +145,13 @@ class String(PythonType):
     __slots__ = tuple()
 
     def __init__(self, nullable=False):
-        super(String, self).__init__(six.string_types, nullable=nullable)
+        super(String, self).__init__(str, nullable=nullable)
 
     def convert(self, value, receiver, context, function_spec, engine,
                 *args, **kwargs):
         value = super(String, self).convert(
             value, receiver, context, function_spec, engine, *args, **kwargs)
-        return None if value is None else six.text_type(value)
+        return None if value is None else str(value)
 
 
 class Integer(PythonType):
@@ -163,7 +159,7 @@ class Integer(PythonType):
 
     def __init__(self, nullable=False):
         super(Integer, self).__init__(
-            six.integer_types, nullable=nullable,
+            int, nullable=nullable,
             validators=[lambda t: not isinstance(t, bool)])
 
 
@@ -189,9 +185,9 @@ class Iterable(PythonType):
 
     def __init__(self, validators=None, nullable=False):
         super(Iterable, self).__init__(
-            collections.Iterable, nullable, [
-                lambda t: not isinstance(t, six.string_types + (
-                    utils.MappingType,))] + (validators or []))
+            collections.Iterable, nullable,
+            [lambda t: not isinstance(t, (str, utils.MappingType))] + (
+                validators or []))
 
     def check(self, value, context, engine, *args, **kwargs):
         if isinstance(value, utils.MappingType) and engine.options.get(
@@ -222,7 +218,7 @@ class Sequence(PythonType):
     def __init__(self, validators=None, nullable=False):
         super(Sequence, self).__init__(
             collections.Sequence, nullable, [
-                lambda t: not isinstance(t, six.string_types + (dict,))] + (
+                lambda t: not isinstance(t, (str, dict))] + (
                     validators or []))
 
 
@@ -231,7 +227,7 @@ class Number(PythonType):
 
     def __init__(self, nullable=False):
         super(Number, self).__init__(
-            six.integer_types + (float,), nullable,
+            (int, float), nullable,
             validators=[lambda t: not isinstance(t, bool)])
 
 
@@ -260,7 +256,7 @@ class Lambda(LazyParameterType, SmartType):
         self._publish_params(context, args, kwargs)
         if isinstance(value, expressions.Expression):
             result = value(receiver, context, engine)
-        elif six.callable(value):
+        elif callable(value):
             result = value(*args, **kwargs)
         else:
             result = value
@@ -273,7 +269,7 @@ class Lambda(LazyParameterType, SmartType):
             *convert_args, **convert_kwargs)
         if value is None:
             return None
-        elif six.callable(value) and hasattr(value, '__unwrapped__'):
+        elif callable(value) and hasattr(value, '__unwrapped__'):
             value = value.__unwrapped__
 
         def func(*args, **kwargs):
@@ -318,7 +314,7 @@ class Super(HiddenParameterType, SmartType):
 
     def convert(self, value, receiver, context, function_spec, engine,
                 *convert_args, **convert_kwargs):
-        if six.callable(value) and hasattr(value, '__unwrapped__'):
+        if callable(value) and hasattr(value, '__unwrapped__'):
             value = value.__unwrapped__
 
         def func(*args, **kwargs):
@@ -377,7 +373,7 @@ class Delegate(HiddenParameterType, SmartType):
 
     def convert(self, value, receiver, context, function_spec, engine,
                 *convert_args, **convert_kwargs):
-        if six.callable(value) and hasattr(value, '__unwrapped__'):
+        if callable(value) and hasattr(value, '__unwrapped__'):
             value = value.__unwrapped__
 
         def func(*args, **kwargs):
@@ -485,7 +481,7 @@ class StringConstant(Constant):
     def check(self, value, context, *args, **kwargs):
         return super(StringConstant, self).check(
             value, context, *args, **kwargs) and (
-            value is None or isinstance(value.value, six.string_types))
+            value is None or isinstance(value.value, str))
 
 
 class Keyword(Constant):
@@ -519,13 +515,12 @@ class NumericConstant(Constant):
     def check(self, value, context, *args, **kwargs):
         return super(NumericConstant, self).check(
             value, context, *args, **kwargs) and (
-            value is None or isinstance(
-                value.value, six.integer_types + (float,)) and
+            value is None or
+            isinstance(value.value, (int, float)) and
             type(value.value) is not bool)
 
 
-@six.add_metaclass(abc.ABCMeta)
-class SmartTypeAggregation(SmartType):
+class SmartTypeAggregation(SmartType, metaclass=abc.ABCMeta):
     __slots__ = ('types',)
 
     def __init__(self, *args, **kwargs):
diff --git a/yaql/standard_library/collections.py b/yaql/standard_library/collections.py
index 8965914..b27c603 100644
--- a/yaql/standard_library/collections.py
+++ b/yaql/standard_library/collections.py
@@ -17,8 +17,6 @@ Functions that produce or consume finite collections - lists, dicts and sets.
 
 import itertools
 
-import six
-
 from yaql.language import specs
 from yaql.language import utils
 from yaql.language import yaqltypes
@@ -328,7 +326,7 @@ def dict_set(engine, d, key, value):
         {"a": 1, "b": 3}
     """
     utils.limit_memory_usage(engine, (1, d), (1, key), (1, value))
-    return utils.FrozenDict(itertools.chain(six.iteritems(d), ((key, value),)))
+    return utils.FrozenDict(itertools.chain(d.items(), ((key, value),)))
 
 
 @specs.parameter('d', utils.MappingType, alias='dict')
@@ -354,8 +352,7 @@ def dict_set_many(engine, d, replacements):
         {"a": 1, "c": 4, "b": 3}
     """
     utils.limit_memory_usage(engine, (1, d), (1, replacements))
-    return utils.FrozenDict(itertools.chain(
-        six.iteritems(d), six.iteritems(replacements)))
+    return utils.FrozenDict(itertools.chain(d.items(), replacements.items()))
 
 
 @specs.no_kwargs
@@ -382,7 +379,7 @@ def dict_set_many_inline(engine, d, *args):
     """
     utils.limit_memory_usage(engine, (1, d), *((1, arg) for arg in args))
     return utils.FrozenDict(itertools.chain(
-        six.iteritems(d), ((t.source, t.destination) for t in args)))
+        d.items(), ((t.source, t.destination) for t in args)))
 
 
 @specs.parameter('d', utils.MappingType, alias='dict')
@@ -403,7 +400,7 @@ def dict_keys(d):
         yaql> {"a" => 1, "b" => 2}.keys()
         ["a", "b"]
     """
-    return six.iterkeys(d)
+    return d.keys()
 
 
 @specs.parameter('d', utils.MappingType, alias='dict')
@@ -424,7 +421,7 @@ def dict_values(d):
         yaql> {"a" => 1, "b" => 2}.values()
         [1, 2]
     """
-    return six.itervalues(d)
+    return d.values()
 
 
 @specs.parameter('d', utils.MappingType, alias='dict')
@@ -445,7 +442,7 @@ def dict_items(d):
         yaql> {"a" => 1, "b" => 2}.items()
         [["a", 1], ["b", 2]]
     """
-    return six.iteritems(d)
+    return d.items()
 
 
 @specs.parameter('lst', yaqltypes.Sequence(), alias='list')
@@ -563,7 +560,7 @@ def contains_value(d, value):
         yaql> {"a" => 1, "b" => 2}.containsValue(2)
         true
     """
-    return value in six.itervalues(d)
+    return value in d.values()
 
 
 @specs.parameter('left', yaqltypes.Iterable())
diff --git a/yaql/standard_library/legacy.py b/yaql/standard_library/legacy.py
index 6c4b927..44f4b27 100644
--- a/yaql/standard_library/legacy.py
+++ b/yaql/standard_library/legacy.py
@@ -19,8 +19,6 @@ Examples are provided with CLI started with legacy mode.
 
 import itertools
 
-import six
-
 from yaql.language import contexts
 from yaql.language import expressions
 from yaql.language import specs
@@ -124,7 +122,7 @@ def indexer(collection, index_expression):
         index = index_expression()
         if isinstance(index, int) and not isinstance(index, bool):
             return collection[index]
-    return six.moves.filter(index_expression, collection)
+    return filter(index_expression, collection)
 
 
 @specs.parameter('start', int)
@@ -153,7 +151,7 @@ def range_(start, stop=None):
     if stop is None:
         return itertools.count(start)
     else:
-        return six.moves.range(start, stop)
+        return range(start, stop)
 
 
 @specs.parameter('conditions', yaqltypes.Lambda(with_context=True))
diff --git a/yaql/standard_library/math.py b/yaql/standard_library/math.py
index 38be2e3..4ef6e19 100644
--- a/yaql/standard_library/math.py
+++ b/yaql/standard_library/math.py
@@ -16,8 +16,6 @@ The Math module describes implemented math operations on numbers.
 """
 import random
 
-import six
-
 from yaql.language import specs
 from yaql.language import yaqltypes
 
@@ -113,8 +111,7 @@ def division(left, right):
         yaql> 3.0 / 2
         1.5
     """
-    if isinstance(left, six.integer_types) and isinstance(
-            right, six.integer_types):
+    if isinstance(left, int) and isinstance(right, int):
         return left // right
     return left / right
 
@@ -654,7 +651,7 @@ def is_integer(value):
         yaql> isInteger(12)
         true
     """
-    return isinstance(value, six.integer_types) and not isinstance(value, bool)
+    return isinstance(value, int) and not isinstance(value, bool)
 
 
 def is_number(value):
@@ -674,8 +671,7 @@ def is_number(value):
         yaql> isNumber(12)
         true
     """
-    return (isinstance(value, six.integer_types + (float,))
-            and not isinstance(value, bool))
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
 
 
 def register(context):
diff --git a/yaql/standard_library/queries.py b/yaql/standard_library/queries.py
index ba60dd8..103529d 100644
--- a/yaql/standard_library/queries.py
+++ b/yaql/standard_library/queries.py
@@ -19,10 +19,8 @@ Queries module.
 # yaql.standard_library.collections
 
 import collections
+import functools
 import itertools
-import sys
-
-import six
 
 from yaql.language import exceptions
 from yaql.language import specs
@@ -110,7 +108,7 @@ def where(collection, predicate):
         yaql> [1, 2, 3, 4, 5].where($ > 3)
         [4, 5]
     """
-    return six.moves.filter(predicate, collection)
+    return filter(predicate, collection)
 
 
 @specs.parameter('collection', yaqltypes.Iterable())
@@ -136,7 +134,7 @@ def select(collection, selector):
         yaql> [{'a'=> 2}, {'a'=> 4}].select($.a)
         [2, 4]
     """
-    return six.moves.map(selector, collection)
+    return map(selector, collection)
 
 
 @specs.parameter('collection', yaqltypes.Iterable())
@@ -161,8 +159,7 @@ def collection_attribution(collection, attribute, operator):
         yaql> [{"a" => 1}, {"a" => 2, "b" => 3}].a
         [1, 2]
     """
-    return six.moves.map(
-        lambda t: operator(t, attribute), collection)
+    return map(lambda t: operator(t, attribute), collection)
 
 
 @specs.parameter('collection', yaqltypes.Iterable())
@@ -554,7 +551,7 @@ def first(collection, default=utils.NO_VALUE):
         3
     """
     try:
-        return six.next(iter(collection))
+        return next(iter(collection))
     except StopIteration:
         if default is utils.NO_VALUE:
             raise
@@ -582,9 +579,9 @@ def single(collection):
         Execution exception: Collection contains more than one item
     """
     it = iter(collection)
-    result = six.next(it)
+    result = next(it)
     try:
-        six.next(it)
+        next(it)
     except StopIteration:
         return result
     raise StopIteration('Collection contains more than one item')
@@ -679,7 +676,7 @@ def range_(stop):
         yaql> range(3)
         [0, 1, 2]
     """
-    return iter(six.moves.range(stop))
+    return iter(range(stop))
 
 
 @specs.parameter('start', int)
@@ -708,7 +705,7 @@ def range__(start, stop, step=1):
         yaql> range(4, 1, -1)
         [4, 3, 2]
     """
-    return iter(six.moves.range(start, stop, step))
+    return iter(range(start, stop, step))
 
 
 @specs.parameter('start', int)
@@ -877,16 +874,20 @@ class GroupAggregator(object):
             key, value_list = group_item
             try:
                 result = self.aggregator(value_list)
-            except (exceptions.NoMatchingMethodException,
-                    exceptions.NoMatchingFunctionException,
-                    IndexError):
-                self._failure_info = sys.exc_info()
+            except (
+                exceptions.NoMatchingMethodException,
+                exceptions.NoMatchingFunctionException,
+                IndexError,
+            ) as exc:
+                self._failure_info = exc
             else:
-                if not (len(value_list) == 2 and
-                        isinstance(result, collections.Sequence) and
-                        not isinstance(result, six.string_types) and
-                        len(result) == 2 and
-                        result[0] == value_list[0]):
+                if not (
+                    len(value_list) == 2 and
+                    isinstance(result, collections.Sequence) and
+                    not isinstance(result, str) and
+                    len(result) == 2 and
+                    result[0] == value_list[0]
+                ):
                     # We are not dealing with (correct) version 1.1.1 syntax,
                     # so don't bother trying to fall back if there's an error
                     # with a later group.
@@ -905,7 +906,7 @@ class GroupAggregator(object):
 
         # If we are unable to successfully fall back, re-raise the first
         # exception encountered to help the user debug in the new style.
-        six.reraise(*self._failure_info)
+        raise self._failure_info
 
 
 def group_by_function(allow_aggregator_fallback):
@@ -952,7 +953,7 @@ def group_by_function(allow_aggregator_fallback):
             value = t if value_selector is None else value_selector(t)
             groups.setdefault(key_selector(t), []).append(value)
             utils.limit_memory_usage(engine, (1, groups))
-        return select(six.iteritems(groups), new_aggregator)
+        return select(groups.items(), new_aggregator)
 
     return group_by
 
@@ -978,7 +979,7 @@ def zip_(*collections):
         yaql> [1, 2, 3].zip([4, 5], [6, 7])
         [[1, 4, 6], [2, 5, 7]]
     """
-    return six.moves.zip(*collections)
+    return zip(*collections)
 
 
 @specs.method
@@ -1008,7 +1009,7 @@ def zip_longest(*collections, **kwargs):
         yaql> [1, 2, 3].zipLongest([4, 5], default => 100)
         [[1, 4], [2, 5], [3, 100]]
     """
-    return six.moves.zip_longest(
+    return itertools.zip_longest(
         *collections, fillvalue=kwargs.pop('default', None))
 
 
@@ -1424,9 +1425,9 @@ def aggregate(collection, selector, seed=utils.NO_VALUE):
         1
     """
     if seed is utils.NO_VALUE:
-        return six.moves.reduce(selector, collection)
+        return functools.reduce(selector, collection)
     else:
-        return six.moves.reduce(selector, collection, seed)
+        return functools.reduce(selector, collection, seed)
 
 
 @specs.method
@@ -1452,7 +1453,7 @@ def reverse(collection, to_list):
 
 def _merge_dicts(dict1, dict2, list_merge_func, item_merger, max_levels=0):
     result = {}
-    for key, value1 in six.iteritems(dict1):
+    for key, value1 in dict1.items():
         result[key] = value1
         if key in dict2:
             value2 = dict2[key]
@@ -1473,7 +1474,7 @@ def _merge_dicts(dict1, dict2, list_merge_func, item_merger, max_levels=0):
             else:
                 result[key] = item_merger(value1, value2)
 
-    for key2, value2 in six.iteritems(dict2):
+    for key2, value2 in dict2.items():
         if key2 not in result:
             result[key2] = value2
     return result
diff --git a/yaql/standard_library/regex.py b/yaql/standard_library/regex.py
index 79b2983..704af6f 100644
--- a/yaql/standard_library/regex.py
+++ b/yaql/standard_library/regex.py
@@ -17,8 +17,6 @@ The module contains functions for regular expressions.
 
 import re
 
-import six
-
 from yaql.language import specs
 from yaql.language import yaqltypes
 
@@ -226,7 +224,7 @@ def _publish_match(context, match):
         }
         context['$' + str(i + 1)] = rec
 
-    for key, value, in six.itervalues(match.groupdict()):
+    for key, value, in match.groupdict().values():
         rec = {
             'value': value,
             'start': match.start(value),
diff --git a/yaql/standard_library/strings.py b/yaql/standard_library/strings.py
index 30925c0..084c699 100644
--- a/yaql/standard_library/strings.py
+++ b/yaql/standard_library/strings.py
@@ -17,8 +17,6 @@ The module describes which operations can be done with strings in YAQL.
 
 import string as string_module
 
-import six
-
 from yaql.language import specs
 from yaql.language import utils
 from yaql.language import yaqltypes
@@ -299,7 +297,7 @@ def join(sequence, separator, str_delegate):
         yaql> ["abc", "de", "f"].join("|")
         "abc|de|f"
     """
-    return separator.join(six.moves.map(str_delegate, sequence))
+    return separator.join(map(str_delegate, sequence))
 
 
 @specs.parameter('sequence', yaqltypes.Iterable())
@@ -351,7 +349,7 @@ def str_(value):
     elif value is False:
         return 'false'
     else:
-        return six.text_type(value)
+        return str(value)
 
 
 @specs.parameter('string', yaqltypes.String())
@@ -561,7 +559,7 @@ def replace_with_dict(string, str_func, replacements, count=-1):
         yaql> "abc ab abc".replace({ab => yy, abc => xx}, 1)
         "yyc ab xx"
     """
-    for key, value in six.iteritems(replacements):
+    for key, value in replacements.items():
         string = string.replace(str_func(key), str_func(value), count)
     return string
 
@@ -955,7 +953,7 @@ def is_string(arg):
         yaql> isString(1)
         false
     """
-    return isinstance(arg, six.string_types)
+    return isinstance(arg, str)
 
 
 @specs.parameter('string', yaqltypes.String())
diff --git a/yaql/standard_library/system.py b/yaql/standard_library/system.py
index 7f64178..e9a6ea5 100644
--- a/yaql/standard_library/system.py
+++ b/yaql/standard_library/system.py
@@ -17,8 +17,6 @@ The module describes main system functions for working with objects.
 
 import itertools
 
-import six
-
 from yaql.language import contexts
 from yaql.language import specs
 from yaql.language import utils
@@ -175,7 +173,7 @@ def let(__context__, *args, **kwargs):
     for i, value in enumerate(args, 1):
         __context__[str(i)] = value
 
-    for key, value in six.iteritems(kwargs):
+    for key, value in kwargs.items():
         __context__[key] = value
     return __context__
 
@@ -267,7 +265,7 @@ def assert__(engine, obj, condition, message=u'Assertion failed'):
 
 @specs.name('#call')
 @specs.parameter('callable_', yaqltypes.PythonType(
-    object, False, validators=(six.callable,)))
+    object, False, validators=(callable,)))
 def call(callable_, *args, **kwargs):
     """:yaql:call
 
diff --git a/yaql/standard_library/yaqlized.py b/yaql/standard_library/yaqlized.py
index 8dac172..8d4e2e5 100644
--- a/yaql/standard_library/yaqlized.py
+++ b/yaql/standard_library/yaqlized.py
@@ -47,8 +47,6 @@ This module provides implemented operators on Yaqlized objects.
 
 import re
 
-import six
-
 from yaql.language import expressions
 from yaql.language import runner
 from yaql.language import specs
@@ -83,7 +81,7 @@ def _match_name_to_entry(name, entry):
         return True
     elif isinstance(entry, REGEX_TYPE):
         return entry.search(name) is not None
-    elif six.callable(entry):
+    elif callable(entry):
         return entry(name)
     return False
 
@@ -143,7 +141,7 @@ def op_dot(receiver, expr, context, engine):
     mappings = _remap_name(expr.name, settings)
 
     _validate_name(expr.name, settings)
-    if not isinstance(mappings, six.string_types):
+    if not isinstance(mappings, str):
         name = mappings[0]
         if len(mappings) > 0:
             arg_mappings = mappings[1]
@@ -156,7 +154,7 @@ def op_dot(receiver, expr, context, engine):
     func = getattr(receiver, name)
     args, kwargs = runner.translate_args(False, expr.args, {})
     args = tuple(arg(utils.NO_VALUE, context, engine) for arg in args)
-    for key, value in six.iteritems(kwargs):
+    for key, value in kwargs.items():
         kwargs[arg_mappings.get(key, key)] = value(
             utils.NO_VALUE, context, engine)
     res = func(*args, **kwargs)
diff --git a/yaql/tests/test_engine.py b/yaql/tests/test_engine.py
index 799e066..9ec57b8 100644
--- a/yaql/tests/test_engine.py
+++ b/yaql/tests/test_engine.py
@@ -12,10 +12,9 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import io
 import sys
 
-import six
-
 import yaql
 from yaql.language import exceptions
 from yaql.language import factory
@@ -28,7 +27,7 @@ class TestEngine(tests.TestCase):
     def test_parser_grammar(self):
         # replace stderr with cString to write to
         copy = sys.stderr
-        sys.stderr = six.StringIO()
+        sys.stderr = io.StringIO()
         try:
             debug_opts = dict(self.engine_options)
             debug_opts['yaql.debug'] = True
diff --git a/yaql/tests/test_type_aggregation.py b/yaql/tests/test_type_aggregation.py
index e878e4b..47eade3 100644
--- a/yaql/tests/test_type_aggregation.py
+++ b/yaql/tests/test_type_aggregation.py
@@ -12,8 +12,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import six
-
 from yaql.language import exceptions
 from yaql.language import specs
 from yaql.language import yaqltypes
@@ -53,9 +51,9 @@ class TestTypeAggregation(yaql.tests.TestCase):
 
     def test_any_of(self):
         @specs.parameter(
-            'arg', yaqltypes.AnyOf(six.string_types, yaqltypes.Integer()))
+            'arg', yaqltypes.AnyOf(str, yaqltypes.Integer()))
         def foo(arg):
-            if isinstance(arg, six.string_types):
+            if isinstance(arg, str):
                 return 1
             if isinstance(arg, int):
                 return 2
diff --git a/yaql/yaql_interface.py b/yaql/yaql_interface.py
index 945cb7b..374ee84 100644
--- a/yaql/yaql_interface.py
+++ b/yaql/yaql_interface.py
@@ -12,8 +12,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import six
-
 from yaql.language import utils
 
 
@@ -56,7 +54,7 @@ class YaqlInterface(object):
             context['$' + str(i + 1)] = arg_value
 
         kwargs = utils.convert_input_data(kwargs)
-        for arg_name, arg_value in six.iteritems(kwargs):
+        for arg_name, arg_value in kwargs.items():
             context['$' + arg_name] = arg_value
 
         parsed = self.engine(__expression)
diff --git a/yaql/yaqlization.py b/yaql/yaqlization.py
index f0c4e0d..926927a 100644
--- a/yaql/yaqlization.py
+++ b/yaql/yaqlization.py
@@ -12,9 +12,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import six
-
-
 YAQLIZATION_ATTR = '__yaqlization__'
 
 
@@ -56,8 +53,8 @@ def build_yaqlization_settings(
     blacklist = set(blacklist or [])
     attribute_remapping = attribute_remapping or {}
     if blacklist_remapped_attributes:
-        for value in six.itervalues(attribute_remapping):
-            if not isinstance(value, six.string_types):
+        for value in attribute_remapping.values():
+            if not isinstance(value, str):
                 name = value[0]
             else:
                 name = value