//@ts-nocheck
/*
 * Generated by PEG.js 0.10.0.
 *
 * http://pegjs.org/
 */

'use strict'

function peg$subclass(child, parent) {
  function ctor() {
    this.constructor = child
  }
  ctor.prototype = parent.prototype
  child.prototype = new ctor()
}

function peg$SyntaxError(message, expected, found, location) {
  this.message = message
  this.expected = expected
  this.found = found
  this.location = location
  this.name = 'SyntaxError'

  if (typeof Error.captureStackTrace === 'function') {
    Error.captureStackTrace(this, peg$SyntaxError)
  }
}

peg$subclass(peg$SyntaxError, Error)

peg$SyntaxError.buildMessage = function (expected, found) {
  var DESCRIBE_EXPECTATION_FNS = {
    literal: function (expectation) {
      return '"' + literalEscape(expectation.text) + '"'
    },

    class: function (expectation) {
      var escapedParts = '',
        i

      for (i = 0; i < expectation.parts.length; i++) {
        escapedParts +=
          expectation.parts[i] instanceof Array
            ? classEscape(expectation.parts[i][0]) +
              '-' +
              classEscape(expectation.parts[i][1])
            : classEscape(expectation.parts[i])
      }

      return '[' + (expectation.inverted ? '^' : '') + escapedParts + ']'
    },

    any: function (expectation) {
      return 'any character'
    },

    end: function (expectation) {
      return 'end of input'
    },

    other: function (expectation) {
      return expectation.description
    },
  }

  function hex(ch) {
    return ch.charCodeAt(0).toString(16).toUpperCase()
  }

  function literalEscape(s) {
    return s
      .replace(/\\/g, '\\\\')
      .replace(/"/g, '\\"')
      .replace(/\0/g, '\\0')
      .replace(/\t/g, '\\t')
      .replace(/\n/g, '\\n')
      .replace(/\r/g, '\\r')
      .replace(/[\x00-\x0F]/g, function (ch) {
        return '\\x0' + hex(ch)
      })
      .replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
        return '\\x' + hex(ch)
      })
  }

  function classEscape(s) {
    return s
      .replace(/\\/g, '\\\\')
      .replace(/\]/g, '\\]')
      .replace(/\^/g, '\\^')
      .replace(/-/g, '\\-')
      .replace(/\0/g, '\\0')
      .replace(/\t/g, '\\t')
      .replace(/\n/g, '\\n')
      .replace(/\r/g, '\\r')
      .replace(/[\x00-\x0F]/g, function (ch) {
        return '\\x0' + hex(ch)
      })
      .replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
        return '\\x' + hex(ch)
      })
  }

  function describeExpectation(expectation) {
    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation)
  }

  function describeExpected(expected) {
    var descriptions = new Array(expected.length),
      i,
      j

    for (i = 0; i < expected.length; i++) {
      descriptions[i] = describeExpectation(expected[i])
    }

    descriptions.sort()

    if (descriptions.length > 0) {
      for (i = 1, j = 1; i < descriptions.length; i++) {
        if (descriptions[i - 1] !== descriptions[i]) {
          descriptions[j] = descriptions[i]
          j++
        }
      }
      descriptions.length = j
    }

    switch (descriptions.length) {
      case 1:
        return descriptions[0]

      case 2:
        return descriptions[0] + ' or ' + descriptions[1]

      default:
        return (
          descriptions.slice(0, -1).join(', ') +
          ', or ' +
          descriptions[descriptions.length - 1]
        )
    }
  }

  function describeFound(found) {
    return found ? '"' + literalEscape(found) + '"' : 'end of input'
  }

  return (
    'Expected ' +
    describeExpected(expected) +
    ' but ' +
    describeFound(found) +
    ' found.'
  )
}

function peg$parse(input, options) {
  options = options !== void 0 ? options : {}

  var peg$FAILED = {},
    peg$startRuleFunctions = { declaration: peg$parsedeclaration },
    peg$startRuleFunction = peg$parsedeclaration,
    peg$c0 = '(',
    peg$c1 = peg$literalExpectation('(', false),
    peg$c2 = ')',
    peg$c3 = peg$literalExpectation(')', false),
    peg$c4 = function (type, name, comment, fields) {
      return { type, name, comment, fields }
    },
    peg$c5 = 'simple',
    peg$c6 = peg$literalExpectation('simple', false),
    peg$c7 = 'object',
    peg$c8 = peg$literalExpectation('object', false),
    peg$c9 = 'table',
    peg$c10 = peg$literalExpectation('table', false),
    peg$c11 = 'auto',
    peg$c12 = peg$literalExpectation('auto', false),
    peg$c13 = 'primary',
    peg$c14 = peg$literalExpectation('primary', false),
    peg$c15 = 'index',
    peg$c16 = peg$literalExpectation('index', false),
    peg$c17 = 'unique',
    peg$c18 = peg$literalExpectation('unique', false),
    peg$c19 = function (f1, w) {
      return w
    },
    peg$c20 = function (f1, fds) {
      if (f1.name) {
        fds.unshift(f1)
      }
      return fds
    },
    peg$c21 = '#',
    peg$c22 = peg$literalExpectation('#', false),
    peg$c23 = ';',
    peg$c24 = peg$literalExpectation(';', false),
    peg$c25 = function (type, name, comment) {
      return { type, name, comment }
    },
    peg$c26 = '[',
    peg$c27 = peg$literalExpectation('[', false),
    peg$c28 = ']',
    peg$c29 = peg$literalExpectation(']', false),
    peg$c30 = function (type, size, name, comment) {
      return { type, size, name, comment }
    },
    peg$c31 = function (type, vals, name, comment) {
      return { type, vals, name, comment }
    },
    peg$c32 = ',',
    peg$c33 = peg$literalExpectation(',', false),
    peg$c34 = function (f1, fds) {
      fds.unshift(f1)
      return fds
    },
    peg$c35 = 'int',
    peg$c36 = peg$literalExpectation('int', false),
    peg$c37 = 'uint',
    peg$c38 = peg$literalExpectation('uint', false),
    peg$c39 = 'short',
    peg$c40 = peg$literalExpectation('short', false),
    peg$c41 = 'ushort',
    peg$c42 = peg$literalExpectation('ushort', false),
    peg$c43 = 'byte',
    peg$c44 = peg$literalExpectation('byte', false),
    peg$c45 = 'ubyte',
    peg$c46 = peg$literalExpectation('ubyte', false),
    peg$c47 = 'float',
    peg$c48 = peg$literalExpectation('float', false),
    peg$c49 = 'char',
    peg$c50 = peg$literalExpectation('char', false),
    peg$c51 = 'string',
    peg$c52 = peg$literalExpectation('string', false),
    peg$c53 = 'lstring',
    peg$c54 = peg$literalExpectation('lstring', false),
    peg$c55 = 'enum',
    peg$c56 = peg$literalExpectation('enum', false),
    peg$c57 = 'double',
    peg$c58 = peg$literalExpectation('double', false),
    peg$c59 = 'bigint',
    peg$c60 = peg$literalExpectation('bigint', false),
    peg$c61 = 'set',
    peg$c62 = peg$literalExpectation('set', false),
    peg$c63 = function (t, n) {
      return t + ' ' + n
    },
    peg$c64 = /^[a-zA-Z_]/,
    peg$c65 = peg$classExpectation([['a', 'z'], ['A', 'Z'], '_'], false, false),
    peg$c66 = /^[a-zA-Z0-9_]/,
    peg$c67 = peg$classExpectation(
      [['a', 'z'], ['A', 'Z'], ['0', '9'], '_'],
      false,
      false,
    ),
    peg$c68 = function (t) {
      return text()
    },
    peg$c69 = '"',
    peg$c70 = peg$literalExpectation('"', false),
    peg$c71 = /^[^"]/,
    peg$c72 = peg$classExpectation(['"'], true, false),
    peg$c73 = function (t) {
      return t.join('')
    },
    peg$c74 = /^[^\n\r]/,
    peg$c75 = peg$classExpectation(['\n', '\r'], true, false),
    peg$c76 = function (t) {
      return t.join('').replace(/^"/, '').replace(/"$/, '')
    },
    peg$c77 = peg$otherExpectation('integer'),
    peg$c78 = /^[0-9]/,
    peg$c79 = peg$classExpectation([['0', '9']], false, false),
    peg$c80 = function () {
      return parseInt(text(), 10)
    },
    peg$c81 = peg$otherExpectation('whitespace'),
    peg$c82 = /^[ \t\n\r]/,
    peg$c83 = peg$classExpectation([' ', '\t', '\n', '\r'], false, false),
    peg$currPos = 0,
    peg$savedPos = 0,
    peg$posDetailsCache = [{ line: 1, column: 1 }],
    peg$maxFailPos = 0,
    peg$maxFailExpected = [],
    peg$silentFails = 0,
    peg$result

  if ('startRule' in options) {
    if (!(options.startRule in peg$startRuleFunctions)) {
      throw new Error(
        'Can\'t start parsing from rule "' + options.startRule + '".',
      )
    }

    peg$startRuleFunction = peg$startRuleFunctions[options.startRule]
  }

  function text() {
    return input.substring(peg$savedPos, peg$currPos)
  }

  function location() {
    return peg$computeLocation(peg$savedPos, peg$currPos)
  }

  function expected(description, location) {
    location =
      location !== void 0
        ? location
        : peg$computeLocation(peg$savedPos, peg$currPos)

    throw peg$buildStructuredError(
      [peg$otherExpectation(description)],
      input.substring(peg$savedPos, peg$currPos),
      location,
    )
  }

  function error(message, location) {
    location =
      location !== void 0
        ? location
        : peg$computeLocation(peg$savedPos, peg$currPos)

    throw peg$buildSimpleError(message, location)
  }

  function peg$literalExpectation(text, ignoreCase) {
    return { type: 'literal', text: text, ignoreCase: ignoreCase }
  }

  function peg$classExpectation(parts, inverted, ignoreCase) {
    return {
      type: 'class',
      parts: parts,
      inverted: inverted,
      ignoreCase: ignoreCase,
    }
  }

  function peg$anyExpectation() {
    return { type: 'any' }
  }

  function peg$endExpectation() {
    return { type: 'end' }
  }

  function peg$otherExpectation(description) {
    return { type: 'other', description: description }
  }

  function peg$computePosDetails(pos) {
    var details = peg$posDetailsCache[pos],
      p

    if (details) {
      return details
    } else {
      p = pos - 1
      while (!peg$posDetailsCache[p]) {
        p--
      }

      details = peg$posDetailsCache[p]
      details = {
        line: details.line,
        column: details.column,
      }

      while (p < pos) {
        if (input.charCodeAt(p) === 10) {
          details.line++
          details.column = 1
        } else {
          details.column++
        }

        p++
      }

      peg$posDetailsCache[pos] = details
      return details
    }
  }

  function peg$computeLocation(startPos, endPos) {
    var startPosDetails = peg$computePosDetails(startPos),
      endPosDetails = peg$computePosDetails(endPos)

    return {
      start: {
        offset: startPos,
        line: startPosDetails.line,
        column: startPosDetails.column,
      },
      end: {
        offset: endPos,
        line: endPosDetails.line,
        column: endPosDetails.column,
      },
    }
  }

  function peg$fail(expected) {
    if (peg$currPos < peg$maxFailPos) {
      return
    }

    if (peg$currPos > peg$maxFailPos) {
      peg$maxFailPos = peg$currPos
      peg$maxFailExpected = []
    }

    peg$maxFailExpected.push(expected)
  }

  function peg$buildSimpleError(message, location) {
    return new peg$SyntaxError(message, null, null, location)
  }

  function peg$buildStructuredError(expected, found, location) {
    return new peg$SyntaxError(
      peg$SyntaxError.buildMessage(expected, found),
      expected,
      found,
      location,
    )
  }

  function peg$parsedeclaration() {
    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13

    s0 = peg$currPos
    s1 = peg$parse_()
    if (s1 !== peg$FAILED) {
      s2 = peg$parsedeclareType()
      if (s2 !== peg$FAILED) {
        s3 = peg$parse_()
        if (s3 !== peg$FAILED) {
          s4 = peg$parsedeclareName()
          if (s4 !== peg$FAILED) {
            s5 = peg$parse_()
            if (s5 !== peg$FAILED) {
              s6 = peg$parsecomment()
              if (s6 !== peg$FAILED) {
                s7 = peg$parse_()
                if (s7 !== peg$FAILED) {
                  if (input.charCodeAt(peg$currPos) === 40) {
                    s8 = peg$c0
                    peg$currPos++
                  } else {
                    s8 = peg$FAILED
                    if (peg$silentFails === 0) {
                      peg$fail(peg$c1)
                    }
                  }
                  if (s8 !== peg$FAILED) {
                    s9 = peg$parse_()
                    if (s9 !== peg$FAILED) {
                      s10 = peg$parsefieldList()
                      if (s10 !== peg$FAILED) {
                        s11 = peg$parse_()
                        if (s11 !== peg$FAILED) {
                          if (input.charCodeAt(peg$currPos) === 41) {
                            s12 = peg$c2
                            peg$currPos++
                          } else {
                            s12 = peg$FAILED
                            if (peg$silentFails === 0) {
                              peg$fail(peg$c3)
                            }
                          }
                          if (s12 !== peg$FAILED) {
                            s13 = peg$parse_()
                            if (s13 !== peg$FAILED) {
                              peg$savedPos = s0
                              s1 = peg$c4(s2, s4, s6, s10)
                              s0 = s1
                            } else {
                              peg$currPos = s0
                              s0 = peg$FAILED
                            }
                          } else {
                            peg$currPos = s0
                            s0 = peg$FAILED
                          }
                        } else {
                          peg$currPos = s0
                          s0 = peg$FAILED
                        }
                      } else {
                        peg$currPos = s0
                        s0 = peg$FAILED
                      }
                    } else {
                      peg$currPos = s0
                      s0 = peg$FAILED
                    }
                  } else {
                    peg$currPos = s0
                    s0 = peg$FAILED
                  }
                } else {
                  peg$currPos = s0
                  s0 = peg$FAILED
                }
              } else {
                peg$currPos = s0
                s0 = peg$FAILED
              }
            } else {
              peg$currPos = s0
              s0 = peg$FAILED
            }
          } else {
            peg$currPos = s0
            s0 = peg$FAILED
          }
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
    } else {
      peg$currPos = s0
      s0 = peg$FAILED
    }

    return s0
  }

  function peg$parsedeclareType() {
    var s0

    if (input.substr(peg$currPos, 6) === peg$c5) {
      s0 = peg$c5
      peg$currPos += 6
    } else {
      s0 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c6)
      }
    }
    if (s0 === peg$FAILED) {
      if (input.substr(peg$currPos, 6) === peg$c7) {
        s0 = peg$c7
        peg$currPos += 6
      } else {
        s0 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c8)
        }
      }
      if (s0 === peg$FAILED) {
        if (input.substr(peg$currPos, 5) === peg$c9) {
          s0 = peg$c9
          peg$currPos += 5
        } else {
          s0 = peg$FAILED
          if (peg$silentFails === 0) {
            peg$fail(peg$c10)
          }
        }
      }
    }

    return s0
  }

  function peg$parsedeclareName() {
    var s0, s1, s2, s3

    s0 = peg$parsename()
    if (s0 === peg$FAILED) {
      s0 = peg$currPos
      s1 = peg$parsename()
      if (s1 !== peg$FAILED) {
        s2 = peg$parseindexType()
        if (s2 !== peg$FAILED) {
          s1 = [s1, s2]
          s0 = s1
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos
        s1 = peg$parsename()
        if (s1 !== peg$FAILED) {
          if (input.substr(peg$currPos, 4) === peg$c11) {
            s2 = peg$c11
            peg$currPos += 4
          } else {
            s2 = peg$FAILED
            if (peg$silentFails === 0) {
              peg$fail(peg$c12)
            }
          }
          if (s2 !== peg$FAILED) {
            s1 = [s1, s2]
            s0 = s1
          } else {
            peg$currPos = s0
            s0 = peg$FAILED
          }
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos
          s1 = peg$parsename()
          if (s1 !== peg$FAILED) {
            s2 = peg$parseindexType()
            if (s2 !== peg$FAILED) {
              if (input.substr(peg$currPos, 4) === peg$c11) {
                s3 = peg$c11
                peg$currPos += 4
              } else {
                s3 = peg$FAILED
                if (peg$silentFails === 0) {
                  peg$fail(peg$c12)
                }
              }
              if (s3 !== peg$FAILED) {
                s1 = [s1, s2, s3]
                s0 = s1
              } else {
                peg$currPos = s0
                s0 = peg$FAILED
              }
            } else {
              peg$currPos = s0
              s0 = peg$FAILED
            }
          } else {
            peg$currPos = s0
            s0 = peg$FAILED
          }
        }
      }
    }

    return s0
  }

  function peg$parseindexType() {
    var s0

    if (input.substr(peg$currPos, 7) === peg$c13) {
      s0 = peg$c13
      peg$currPos += 7
    } else {
      s0 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c14)
      }
    }
    if (s0 === peg$FAILED) {
      if (input.substr(peg$currPos, 5) === peg$c15) {
        s0 = peg$c15
        peg$currPos += 5
      } else {
        s0 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c16)
        }
      }
      if (s0 === peg$FAILED) {
        if (input.substr(peg$currPos, 6) === peg$c17) {
          s0 = peg$c17
          peg$currPos += 6
        } else {
          s0 = peg$FAILED
          if (peg$silentFails === 0) {
            peg$fail(peg$c18)
          }
        }
      }
    }

    return s0
  }

  function peg$parsecomment() {
    var s0

    s0 = peg$parsenonQuotedString()
    if (s0 === peg$FAILED) {
      s0 = peg$parse_()
    }

    return s0
  }

  function peg$parsefieldList() {
    var s0, s1, s2, s3, s4, s5, s6

    s0 = peg$currPos
    s1 = peg$parsefield()
    if (s1 !== peg$FAILED) {
      s2 = peg$parse_()
      if (s2 !== peg$FAILED) {
        s3 = []
        s4 = peg$currPos
        s5 = peg$parse_()
        if (s5 !== peg$FAILED) {
          s6 = peg$parsefield()
          if (s6 !== peg$FAILED) {
            peg$savedPos = s4
            s5 = peg$c19(s1, s6)
            s4 = s5
          } else {
            peg$currPos = s4
            s4 = peg$FAILED
          }
        } else {
          peg$currPos = s4
          s4 = peg$FAILED
        }
        while (s4 !== peg$FAILED) {
          s3.push(s4)
          s4 = peg$currPos
          s5 = peg$parse_()
          if (s5 !== peg$FAILED) {
            s6 = peg$parsefield()
            if (s6 !== peg$FAILED) {
              peg$savedPos = s4
              s5 = peg$c19(s1, s6)
              s4 = s5
            } else {
              peg$currPos = s4
              s4 = peg$FAILED
            }
          } else {
            peg$currPos = s4
            s4 = peg$FAILED
          }
        }
        if (s3 !== peg$FAILED) {
          s4 = peg$parse_()
          if (s4 !== peg$FAILED) {
            peg$savedPos = s0
            s1 = peg$c20(s1, s3)
            s0 = s1
          } else {
            peg$currPos = s0
            s0 = peg$FAILED
          }
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
    } else {
      peg$currPos = s0
      s0 = peg$FAILED
    }

    return s0
  }

  function peg$parsecommentStart() {
    var s0

    if (input.charCodeAt(peg$currPos) === 35) {
      s0 = peg$c21
      peg$currPos++
    } else {
      s0 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c22)
      }
    }

    return s0
  }

  function peg$parseinternalComment() {
    var s0, s1, s2, s3, s4

    s0 = peg$currPos
    s1 = peg$parse_()
    if (s1 !== peg$FAILED) {
      s2 = peg$parsecommentStart()
      if (s2 !== peg$FAILED) {
        s3 = peg$parsenonQuotedString()
        if (s3 !== peg$FAILED) {
          s4 = peg$parse_()
          if (s4 !== peg$FAILED) {
            s1 = [s1, s2, s3, s4]
            s0 = s1
          } else {
            peg$currPos = s0
            s0 = peg$FAILED
          }
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
    } else {
      peg$currPos = s0
      s0 = peg$FAILED
    }

    return s0
  }

  function peg$parsefield() {
    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13

    s0 = peg$currPos
    s1 = peg$parsefieldType()
    if (s1 !== peg$FAILED) {
      s2 = peg$parse_()
      if (s2 !== peg$FAILED) {
        s3 = peg$parsename()
        if (s3 !== peg$FAILED) {
          s4 = peg$parse_()
          if (s4 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 59) {
              s5 = peg$c23
              peg$currPos++
            } else {
              s5 = peg$FAILED
              if (peg$silentFails === 0) {
                peg$fail(peg$c24)
              }
            }
            if (s5 !== peg$FAILED) {
              s6 = peg$parse_()
              if (s6 !== peg$FAILED) {
                s7 = peg$parsecomment()
                if (s7 !== peg$FAILED) {
                  peg$savedPos = s0
                  s1 = peg$c25(s1, s3, s7)
                  s0 = s1
                } else {
                  peg$currPos = s0
                  s0 = peg$FAILED
                }
              } else {
                peg$currPos = s0
                s0 = peg$FAILED
              }
            } else {
              peg$currPos = s0
              s0 = peg$FAILED
            }
          } else {
            peg$currPos = s0
            s0 = peg$FAILED
          }
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
    } else {
      peg$currPos = s0
      s0 = peg$FAILED
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos
      s1 = peg$parsefieldType()
      if (s1 !== peg$FAILED) {
        s2 = peg$parse_()
        if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 91) {
            s3 = peg$c26
            peg$currPos++
          } else {
            s3 = peg$FAILED
            if (peg$silentFails === 0) {
              peg$fail(peg$c27)
            }
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$parse_()
            if (s4 !== peg$FAILED) {
              s5 = peg$parsefieldSize()
              if (s5 !== peg$FAILED) {
                s6 = peg$parse_()
                if (s6 !== peg$FAILED) {
                  if (input.charCodeAt(peg$currPos) === 93) {
                    s7 = peg$c28
                    peg$currPos++
                  } else {
                    s7 = peg$FAILED
                    if (peg$silentFails === 0) {
                      peg$fail(peg$c29)
                    }
                  }
                  if (s7 !== peg$FAILED) {
                    s8 = peg$parse_()
                    if (s8 !== peg$FAILED) {
                      s9 = peg$parsename()
                      if (s9 !== peg$FAILED) {
                        s10 = peg$parse_()
                        if (s10 !== peg$FAILED) {
                          if (input.charCodeAt(peg$currPos) === 59) {
                            s11 = peg$c23
                            peg$currPos++
                          } else {
                            s11 = peg$FAILED
                            if (peg$silentFails === 0) {
                              peg$fail(peg$c24)
                            }
                          }
                          if (s11 !== peg$FAILED) {
                            s12 = peg$parse_()
                            if (s12 !== peg$FAILED) {
                              s13 = peg$parsecomment()
                              if (s13 !== peg$FAILED) {
                                peg$savedPos = s0
                                s1 = peg$c30(s1, s5, s9, s13)
                                s0 = s1
                              } else {
                                peg$currPos = s0
                                s0 = peg$FAILED
                              }
                            } else {
                              peg$currPos = s0
                              s0 = peg$FAILED
                            }
                          } else {
                            peg$currPos = s0
                            s0 = peg$FAILED
                          }
                        } else {
                          peg$currPos = s0
                          s0 = peg$FAILED
                        }
                      } else {
                        peg$currPos = s0
                        s0 = peg$FAILED
                      }
                    } else {
                      peg$currPos = s0
                      s0 = peg$FAILED
                    }
                  } else {
                    peg$currPos = s0
                    s0 = peg$FAILED
                  }
                } else {
                  peg$currPos = s0
                  s0 = peg$FAILED
                }
              } else {
                peg$currPos = s0
                s0 = peg$FAILED
              }
            } else {
              peg$currPos = s0
              s0 = peg$FAILED
            }
          } else {
            peg$currPos = s0
            s0 = peg$FAILED
          }
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos
        s1 = peg$parsefieldType()
        if (s1 !== peg$FAILED) {
          s2 = peg$parse_()
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 40) {
              s3 = peg$c0
              peg$currPos++
            } else {
              s3 = peg$FAILED
              if (peg$silentFails === 0) {
                peg$fail(peg$c1)
              }
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$parse_()
              if (s4 !== peg$FAILED) {
                s5 = peg$parsefieldValues()
                if (s5 !== peg$FAILED) {
                  s6 = peg$parse_()
                  if (s6 !== peg$FAILED) {
                    if (input.charCodeAt(peg$currPos) === 41) {
                      s7 = peg$c2
                      peg$currPos++
                    } else {
                      s7 = peg$FAILED
                      if (peg$silentFails === 0) {
                        peg$fail(peg$c3)
                      }
                    }
                    if (s7 !== peg$FAILED) {
                      s8 = peg$parse_()
                      if (s8 !== peg$FAILED) {
                        s9 = peg$parsename()
                        if (s9 !== peg$FAILED) {
                          s10 = peg$parse_()
                          if (s10 !== peg$FAILED) {
                            if (input.charCodeAt(peg$currPos) === 59) {
                              s11 = peg$c23
                              peg$currPos++
                            } else {
                              s11 = peg$FAILED
                              if (peg$silentFails === 0) {
                                peg$fail(peg$c24)
                              }
                            }
                            if (s11 !== peg$FAILED) {
                              s12 = peg$parse_()
                              if (s12 !== peg$FAILED) {
                                s13 = peg$parsecomment()
                                if (s13 !== peg$FAILED) {
                                  peg$savedPos = s0
                                  s1 = peg$c31(s1, s5, s9, s13)
                                  s0 = s1
                                } else {
                                  peg$currPos = s0
                                  s0 = peg$FAILED
                                }
                              } else {
                                peg$currPos = s0
                                s0 = peg$FAILED
                              }
                            } else {
                              peg$currPos = s0
                              s0 = peg$FAILED
                            }
                          } else {
                            peg$currPos = s0
                            s0 = peg$FAILED
                          }
                        } else {
                          peg$currPos = s0
                          s0 = peg$FAILED
                        }
                      } else {
                        peg$currPos = s0
                        s0 = peg$FAILED
                      }
                    } else {
                      peg$currPos = s0
                      s0 = peg$FAILED
                    }
                  } else {
                    peg$currPos = s0
                    s0 = peg$FAILED
                  }
                } else {
                  peg$currPos = s0
                  s0 = peg$FAILED
                }
              } else {
                peg$currPos = s0
                s0 = peg$FAILED
              }
            } else {
              peg$currPos = s0
              s0 = peg$FAILED
            }
          } else {
            peg$currPos = s0
            s0 = peg$FAILED
          }
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
        if (s0 === peg$FAILED) {
          s0 = peg$parseinternalComment()
        }
      }
    }

    return s0
  }

  function peg$parsefieldValues() {
    var s0, s1, s2, s3, s4, s5, s6

    s0 = peg$currPos
    s1 = peg$parsename()
    if (s1 !== peg$FAILED) {
      s2 = []
      s3 = peg$currPos
      if (input.charCodeAt(peg$currPos) === 44) {
        s4 = peg$c32
        peg$currPos++
      } else {
        s4 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c33)
        }
      }
      if (s4 !== peg$FAILED) {
        s5 = peg$parse_()
        if (s5 !== peg$FAILED) {
          s6 = peg$parsename()
          if (s6 !== peg$FAILED) {
            peg$savedPos = s3
            s4 = peg$c19(s1, s6)
            s3 = s4
          } else {
            peg$currPos = s3
            s3 = peg$FAILED
          }
        } else {
          peg$currPos = s3
          s3 = peg$FAILED
        }
      } else {
        peg$currPos = s3
        s3 = peg$FAILED
      }
      while (s3 !== peg$FAILED) {
        s2.push(s3)
        s3 = peg$currPos
        if (input.charCodeAt(peg$currPos) === 44) {
          s4 = peg$c32
          peg$currPos++
        } else {
          s4 = peg$FAILED
          if (peg$silentFails === 0) {
            peg$fail(peg$c33)
          }
        }
        if (s4 !== peg$FAILED) {
          s5 = peg$parse_()
          if (s5 !== peg$FAILED) {
            s6 = peg$parsename()
            if (s6 !== peg$FAILED) {
              peg$savedPos = s3
              s4 = peg$c19(s1, s6)
              s3 = s4
            } else {
              peg$currPos = s3
              s3 = peg$FAILED
            }
          } else {
            peg$currPos = s3
            s3 = peg$FAILED
          }
        } else {
          peg$currPos = s3
          s3 = peg$FAILED
        }
      }
      if (s2 !== peg$FAILED) {
        peg$savedPos = s0
        s1 = peg$c34(s1, s2)
        s0 = s1
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
    } else {
      peg$currPos = s0
      s0 = peg$FAILED
    }

    return s0
  }

  function peg$parsefieldType() {
    var s0, s1, s2, s3

    if (input.substr(peg$currPos, 3) === peg$c35) {
      s0 = peg$c35
      peg$currPos += 3
    } else {
      s0 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c36)
      }
    }
    if (s0 === peg$FAILED) {
      if (input.substr(peg$currPos, 4) === peg$c37) {
        s0 = peg$c37
        peg$currPos += 4
      } else {
        s0 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c38)
        }
      }
      if (s0 === peg$FAILED) {
        if (input.substr(peg$currPos, 5) === peg$c39) {
          s0 = peg$c39
          peg$currPos += 5
        } else {
          s0 = peg$FAILED
          if (peg$silentFails === 0) {
            peg$fail(peg$c40)
          }
        }
        if (s0 === peg$FAILED) {
          if (input.substr(peg$currPos, 6) === peg$c41) {
            s0 = peg$c41
            peg$currPos += 6
          } else {
            s0 = peg$FAILED
            if (peg$silentFails === 0) {
              peg$fail(peg$c42)
            }
          }
          if (s0 === peg$FAILED) {
            if (input.substr(peg$currPos, 4) === peg$c43) {
              s0 = peg$c43
              peg$currPos += 4
            } else {
              s0 = peg$FAILED
              if (peg$silentFails === 0) {
                peg$fail(peg$c44)
              }
            }
            if (s0 === peg$FAILED) {
              if (input.substr(peg$currPos, 5) === peg$c45) {
                s0 = peg$c45
                peg$currPos += 5
              } else {
                s0 = peg$FAILED
                if (peg$silentFails === 0) {
                  peg$fail(peg$c46)
                }
              }
              if (s0 === peg$FAILED) {
                if (input.substr(peg$currPos, 5) === peg$c47) {
                  s0 = peg$c47
                  peg$currPos += 5
                } else {
                  s0 = peg$FAILED
                  if (peg$silentFails === 0) {
                    peg$fail(peg$c48)
                  }
                }
                if (s0 === peg$FAILED) {
                  if (input.substr(peg$currPos, 4) === peg$c49) {
                    s0 = peg$c49
                    peg$currPos += 4
                  } else {
                    s0 = peg$FAILED
                    if (peg$silentFails === 0) {
                      peg$fail(peg$c50)
                    }
                  }
                  if (s0 === peg$FAILED) {
                    if (input.substr(peg$currPos, 6) === peg$c51) {
                      s0 = peg$c51
                      peg$currPos += 6
                    } else {
                      s0 = peg$FAILED
                      if (peg$silentFails === 0) {
                        peg$fail(peg$c52)
                      }
                    }
                    if (s0 === peg$FAILED) {
                      if (input.substr(peg$currPos, 7) === peg$c53) {
                        s0 = peg$c53
                        peg$currPos += 7
                      } else {
                        s0 = peg$FAILED
                        if (peg$silentFails === 0) {
                          peg$fail(peg$c54)
                        }
                      }
                      if (s0 === peg$FAILED) {
                        if (input.substr(peg$currPos, 4) === peg$c55) {
                          s0 = peg$c55
                          peg$currPos += 4
                        } else {
                          s0 = peg$FAILED
                          if (peg$silentFails === 0) {
                            peg$fail(peg$c56)
                          }
                        }
                        if (s0 === peg$FAILED) {
                          if (input.substr(peg$currPos, 6) === peg$c57) {
                            s0 = peg$c57
                            peg$currPos += 6
                          } else {
                            s0 = peg$FAILED
                            if (peg$silentFails === 0) {
                              peg$fail(peg$c58)
                            }
                          }
                          if (s0 === peg$FAILED) {
                            if (input.substr(peg$currPos, 6) === peg$c59) {
                              s0 = peg$c59
                              peg$currPos += 6
                            } else {
                              s0 = peg$FAILED
                              if (peg$silentFails === 0) {
                                peg$fail(peg$c60)
                              }
                            }
                            if (s0 === peg$FAILED) {
                              if (input.substr(peg$currPos, 3) === peg$c61) {
                                s0 = peg$c61
                                peg$currPos += 3
                              } else {
                                s0 = peg$FAILED
                                if (peg$silentFails === 0) {
                                  peg$fail(peg$c62)
                                }
                              }
                              if (s0 === peg$FAILED) {
                                s0 = peg$currPos
                                s1 = peg$parsedeclareType()
                                if (s1 !== peg$FAILED) {
                                  s2 = peg$parse_()
                                  if (s2 !== peg$FAILED) {
                                    s3 = peg$parsedeclareName()
                                    if (s3 !== peg$FAILED) {
                                      peg$savedPos = s0
                                      s1 = peg$c63(s1, s3)
                                      s0 = s1
                                    } else {
                                      peg$currPos = s0
                                      s0 = peg$FAILED
                                    }
                                  } else {
                                    peg$currPos = s0
                                    s0 = peg$FAILED
                                  }
                                } else {
                                  peg$currPos = s0
                                  s0 = peg$FAILED
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }

    return s0
  }

  function peg$parsefieldSize() {
    var s0

    s0 = peg$parsenumber()
    if (s0 === peg$FAILED) {
      s0 = peg$parsename()
    }

    return s0
  }

  function peg$parsename() {
    var s0, s1, s2, s3, s4

    s0 = peg$currPos
    s1 = peg$currPos
    if (peg$c64.test(input.charAt(peg$currPos))) {
      s2 = input.charAt(peg$currPos)
      peg$currPos++
    } else {
      s2 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c65)
      }
    }
    if (s2 !== peg$FAILED) {
      s3 = []
      if (peg$c66.test(input.charAt(peg$currPos))) {
        s4 = input.charAt(peg$currPos)
        peg$currPos++
      } else {
        s4 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c67)
        }
      }
      while (s4 !== peg$FAILED) {
        s3.push(s4)
        if (peg$c66.test(input.charAt(peg$currPos))) {
          s4 = input.charAt(peg$currPos)
          peg$currPos++
        } else {
          s4 = peg$FAILED
          if (peg$silentFails === 0) {
            peg$fail(peg$c67)
          }
        }
      }
      if (s3 !== peg$FAILED) {
        s2 = [s2, s3]
        s1 = s2
      } else {
        peg$currPos = s1
        s1 = peg$FAILED
      }
    } else {
      peg$currPos = s1
      s1 = peg$FAILED
    }
    if (s1 !== peg$FAILED) {
      peg$savedPos = s0
      s1 = peg$c68(s1)
    }
    s0 = s1

    return s0
  }

  function peg$parsequotedString() {
    var s0, s1, s2, s3

    s0 = peg$currPos
    if (input.charCodeAt(peg$currPos) === 34) {
      s1 = peg$c69
      peg$currPos++
    } else {
      s1 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c70)
      }
    }
    if (s1 !== peg$FAILED) {
      s2 = []
      if (peg$c71.test(input.charAt(peg$currPos))) {
        s3 = input.charAt(peg$currPos)
        peg$currPos++
      } else {
        s3 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c72)
        }
      }
      while (s3 !== peg$FAILED) {
        s2.push(s3)
        if (peg$c71.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos)
          peg$currPos++
        } else {
          s3 = peg$FAILED
          if (peg$silentFails === 0) {
            peg$fail(peg$c72)
          }
        }
      }
      if (s2 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 34) {
          s3 = peg$c69
          peg$currPos++
        } else {
          s3 = peg$FAILED
          if (peg$silentFails === 0) {
            peg$fail(peg$c70)
          }
        }
        if (s3 !== peg$FAILED) {
          peg$savedPos = s0
          s1 = peg$c73(s2)
          s0 = s1
        } else {
          peg$currPos = s0
          s0 = peg$FAILED
        }
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
    } else {
      peg$currPos = s0
      s0 = peg$FAILED
    }

    return s0
  }

  function peg$parsenonQuotedString() {
    var s0, s1, s2

    s0 = peg$currPos
    s1 = []
    if (peg$c74.test(input.charAt(peg$currPos))) {
      s2 = input.charAt(peg$currPos)
      peg$currPos++
    } else {
      s2 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c75)
      }
    }
    while (s2 !== peg$FAILED) {
      s1.push(s2)
      if (peg$c74.test(input.charAt(peg$currPos))) {
        s2 = input.charAt(peg$currPos)
        peg$currPos++
      } else {
        s2 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c75)
        }
      }
    }
    if (s1 !== peg$FAILED) {
      peg$savedPos = s0
      s1 = peg$c76(s1)
    }
    s0 = s1

    return s0
  }

  function peg$parsenumber() {
    var s0, s1, s2, s3

    peg$silentFails++
    s0 = peg$currPos
    s1 = peg$parse_()
    if (s1 !== peg$FAILED) {
      s2 = []
      if (peg$c78.test(input.charAt(peg$currPos))) {
        s3 = input.charAt(peg$currPos)
        peg$currPos++
      } else {
        s3 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c79)
        }
      }
      if (s3 !== peg$FAILED) {
        while (s3 !== peg$FAILED) {
          s2.push(s3)
          if (peg$c78.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos)
            peg$currPos++
          } else {
            s3 = peg$FAILED
            if (peg$silentFails === 0) {
              peg$fail(peg$c79)
            }
          }
        }
      } else {
        s2 = peg$FAILED
      }
      if (s2 !== peg$FAILED) {
        peg$savedPos = s0
        s1 = peg$c80()
        s0 = s1
      } else {
        peg$currPos = s0
        s0 = peg$FAILED
      }
    } else {
      peg$currPos = s0
      s0 = peg$FAILED
    }
    peg$silentFails--
    if (s0 === peg$FAILED) {
      s1 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c77)
      }
    }

    return s0
  }

  function peg$parse_() {
    var s0, s1

    peg$silentFails++
    s0 = []
    if (peg$c82.test(input.charAt(peg$currPos))) {
      s1 = input.charAt(peg$currPos)
      peg$currPos++
    } else {
      s1 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c83)
      }
    }
    while (s1 !== peg$FAILED) {
      s0.push(s1)
      if (peg$c82.test(input.charAt(peg$currPos))) {
        s1 = input.charAt(peg$currPos)
        peg$currPos++
      } else {
        s1 = peg$FAILED
        if (peg$silentFails === 0) {
          peg$fail(peg$c83)
        }
      }
    }
    peg$silentFails--
    if (s0 === peg$FAILED) {
      s1 = peg$FAILED
      if (peg$silentFails === 0) {
        peg$fail(peg$c81)
      }
    }

    return s0
  }

  peg$result = peg$startRuleFunction()

  if (peg$result !== peg$FAILED && peg$currPos === input.length) {
    return peg$result
  } else {
    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
      peg$fail(peg$endExpectation())
    }

    throw peg$buildStructuredError(
      peg$maxFailExpected,
      peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
      peg$maxFailPos < input.length
        ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
        : peg$computeLocation(peg$maxFailPos, peg$maxFailPos),
    )
  }
}

export default {
  SyntaxError: peg$SyntaxError,
  parse: peg$parse,
}