跳转到内容

std.zig.parser_generated_oracle

标准库Zig 0.17.0官方原文
源码std/zig/parser_generated_oracle.zig

第 1 行

此文件自动生成,请勿手动编辑!生成命令: zig build gen-parser-oracle

std.zig.parser_generated_oracle.Def

容器

第 16 行

字段

defRoot
defContainerMembers
defContainerMembersRest
defContainerDecl
defContainerDeclPrefix
defTestDecl
defComptimeDecl
defDecl
defDeclPrefix
defFnProto
defVarDeclProto
defGlobalVarDecl
defContainerField
defBlockStatement
defStatement
defStatementPrefix
defIfStatement
defLabeledStatement
defLoopStatement
defForStatement
defWhileStatement
defBlockExprStatement
defBlockExprPrefix
defBlockExpr
defVarAssignStatement
defAssignExpr
defSingleAssignExpr
defExpr
defBoolOrExpr
defBoolAndExpr
defCompareExpr
defBitwiseExpr
defBitShiftExpr
defAdditionExpr
defMultiplyExpr
defPrefixExpr
defPrimaryExpr
defIfExpr
defBlock
defLoopExpr
defForExpr
defWhileExpr
defCurlySuffixExpr
defInitList
defTypeExpr
defErrorUnionExpr
defSuffixExpr
defPrimaryTypeExpr
defContainerType
defErrorSetDecl
defGroupedExpr
defIfTypeExpr
defLabeledTypeExpr
defLoopTypeExpr
defForTypeExpr
defWhileTypeExpr
defSwitchExpr
defAsmExpr
defAsmOutput
defAsmOutputItem
defAsmInput
defAsmInputItem
defAsmClobbers
defBreakLabel
defBlockLabel
defFieldInit
defWhileContinueExpr
defLinkSection
defAddrSpace
defCallConv
defParamDecl
defParamType
defIfPrefix
defWhilePrefix
defForPrefix
defPayload
defPtrPayload
defPtrIndexPayload
defPtrListPayload
defSwitchProng
defSwitchCase
defSwitchItem
defForArgumentsList
defForItem
defAssignOp
defOrOp
defAndOp
defCompareOp
defCompareOpTok
defBitwiseOp
defBitwiseOpTok
defBitShiftOp
defBitShiftOpTok
defAdditionOp
defAdditionOpTok
defMultiplyOp
defMultiplyOpTok
defPrefixOp
defPrefixTypeOp
defPtrMods
defSinglePtrMods
defPtrMod
defPrefixTypeOpPrefix
defSuffixOp
defSuffixOpPrefix
defFnCallArguments
defSliceTypeStart
defSinglePtrTypeStart
defManyPtrTypeStart
defArrayTypeStart
defContainerTypeAuto
defContainerTypeKind
defByteAlign
defBitAlign
defIdentifierList
defSwitchProngList
defAsmOutputList
defAsmInputList
defParamDeclList
defParamDeclListRest
defExprList
defExprPrefix
defbyte_order_mark
defsof
defeof
defox80_oxBF
defoxF4
defox80_ox8F
defoxF1_oxF3
defoxF0
defox90_0xBF
defoxEE_oxEF
defoxED
defox80_ox9F
defoxE1_oxEC
defoxE0
defoxA0_oxBF
defoxC2_oxDF
defmultibyte_utf8
defnon_control_ascii
defnon_control_utf8
defchar_char
defstring_char
defcontainer_doc_comment
defdoc_comment
defline_comment
defline_string
defnewline
defskip
defskip_require_newline
defpre_op_white
defpost_op_white
defCHAR_LITERAL
defdigit
defdigit_int
defdigit_float
defNUMBERLITERAL
defstring
defSTRINGLITERALSINGLE
defSTRINGLITERAL
defIDENTIFIER
defBUILTINIDENTIFIER
defAMPERSAND
defAMPERSANDEQUAL
defASTERISK
defASTERISKEQUAL
defASTERISKPERCENT
defASTERISKPERCENTEQUAL
defASTERISKPIPE
defASTERISKPIPEEQUAL
defCARET
defCARETEQUAL
defCOLON
defCOMMA
defDOT
defDOT2
defDOT3
defDOTASTERISK
defEQUAL
defEQUALEQUAL
defEQUALRARROW
defEXCLAMATIONMARK
defEXCLAMATIONMARKEQUAL
defLARROW
defLARROW2
defLARROW2EQUAL
defLARROW2PIPE
defLARROW2PIPEEQUAL
defLARROWEQUAL
defLBRACE
defLBRACKET
defLPAREN
defMINUS
defMINUSEQUAL
defMINUSPERCENT
defMINUSPERCENTEQUAL
defMINUSPIPE
defMINUSPIPEEQUAL
defMINUSRARROW
defPERCENT
defPERCENTEQUAL
defPIPE
defPIPE2
defPIPEEQUAL
defPLUS
defPLUS2
defPLUSEQUAL
defPLUSPERCENT
defPLUSPERCENTEQUAL
defPLUSPIPE
defPLUSPIPEEQUAL
defLETTERC
defQUESTIONMARK
defRARROW
defRARROW2
defRARROW2EQUAL
defRARROWEQUAL
defRBRACE
defRBRACKET
defRPAREN
defSEMICOLON
defSLASH
defSLASHEQUAL
defTILDE
defend_of_word
defKEYWORD_addrspace
defKEYWORD_align
defKEYWORD_allowzero
defKEYWORD_and
defKEYWORD_anyframe
defKEYWORD_anytype
defKEYWORD_asm
defKEYWORD_break
defKEYWORD_callconv
defKEYWORD_catch
defKEYWORD_comptime
defKEYWORD_const
defKEYWORD_continue
defKEYWORD_defer
defKEYWORD_else
defKEYWORD_enum
defKEYWORD_errdefer
defKEYWORD_error
defKEYWORD_export
defKEYWORD_extern
defKEYWORD_fn
defKEYWORD_for
defKEYWORD_if
defKEYWORD_inline
defKEYWORD_noalias
defKEYWORD_nosuspend
defKEYWORD_noinline
defKEYWORD_opaque
defKEYWORD_or
defKEYWORD_orelse
defKEYWORD_packed
defKEYWORD_pub
defKEYWORD_resume
defKEYWORD_return
defKEYWORD_linksection
defKEYWORD_struct
defKEYWORD_suspend
defKEYWORD_switch
defKEYWORD_test
defKEYWORD_threadlocal
defKEYWORD_try
defKEYWORD_union
defKEYWORD_unreachable
defKEYWORD_var
defKEYWORD_volatile
defKEYWORD_while
defkeyword

std.zig.parser_generated_oracle.Error

错误集合

第 6 行

错误

MaxDepth

std.zig.parser_generated_oracle.max_depth

常量

第 7 行

std.zig.parser_generated_oracle.parse

函数

第 12 行

若输入源属于语法定义的语言,返回 true。 递归/迭代层数超过 max_depth 时,返回 error.MaxDepth。

pub fn parse(source: []const u8) Error!bool

参数

source: []const u8

错误

MaxDepth

std.zig.parser_generated_oracle.Parser

容器

第 290 行

字段

source: []const u8
i: usize
depths: [272]u8

std.zig.parser_generated_oracle.Parser.parseAdditionExpr

函数

第 1110 行

pub fn parseAdditionExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAdditionOp

函数

第 2370 行

pub fn parseAdditionOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAdditionOpTok

函数

第 2394 行

pub fn parseAdditionOpTok(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAddrSpace

函数

第 1844 行

pub fn parseAddrSpace(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAMPERSAND

函数

第 4188 行

pub fn parseAMPERSAND(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAMPERSANDEQUAL

函数

第 4218 行

pub fn parseAMPERSANDEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAndOp

函数

第 2192 行

pub fn parseAndOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseArrayTypeStart

函数

第 2801 行

pub fn parseArrayTypeStart(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAsmClobbers

函数

第 1772 行

pub fn parseAsmClobbers(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAsmExpr

函数

第 1705 行

pub fn parseAsmExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAsmInput

函数

第 1748 行

pub fn parseAsmInput(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAsmInputItem

函数

第 1760 行

pub fn parseAsmInputItem(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAsmInputList

函数

第 2975 行

pub fn parseAsmInputList(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAsmOutput

函数

第 1717 行

pub fn parseAsmOutput(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAsmOutputItem

函数

第 1729 行

pub fn parseAsmOutputItem(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAsmOutputList

函数

第 2953 行

pub fn parseAsmOutputList(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAssignExpr

函数

第 891 行

pub fn parseAssignExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseAssignOp

函数

第 2122 行

pub fn parseAssignOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseASTERISK

函数

第 4236 行

pub fn parseASTERISK(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseASTERISKEQUAL

函数

第 4268 行

pub fn parseASTERISKEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseASTERISKPERCENT

函数

第 4286 行

pub fn parseASTERISKPERCENT(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseASTERISKPERCENTEQUAL

函数

第 4316 行

pub fn parseASTERISKPERCENTEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseASTERISKPIPE

函数

第 4334 行

pub fn parseASTERISKPIPE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseASTERISKPIPEEQUAL

函数

第 4364 行

pub fn parseASTERISKPIPEEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBitAlign

函数

第 2892 行

pub fn parseBitAlign(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBitShiftExpr

函数

第 1081 行

pub fn parseBitShiftExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBitShiftOp

函数

第 2330 行

pub fn parseBitShiftOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBitShiftOpTok

函数

第 2354 行

pub fn parseBitShiftOpTok(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBitwiseExpr

函数

第 1052 行

pub fn parseBitwiseExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBitwiseOp

函数

第 2262 行

pub fn parseBitwiseOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBitwiseOpTok

函数

第 2300 行

pub fn parseBitwiseOpTok(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBlock

函数

第 1284 行

pub fn parseBlock(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBlockExpr

函数

第 841 行

pub fn parseBlockExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBlockExprPrefix

函数

第 829 行

pub fn parseBlockExprPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBlockExprStatement

函数

第 810 行

pub fn parseBlockExprStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBlockLabel

函数

第 1796 行

pub fn parseBlockLabel(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBlockStatement

函数

第 572 行

pub fn parseBlockStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBoolAndExpr

函数

第 1001 行

pub fn parseBoolAndExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBoolOrExpr

函数

第 972 行

pub fn parseBoolOrExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBreakLabel

函数

第 1784 行

pub fn parseBreakLabel(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseBUILTINIDENTIFIER

函数

第 4144 行

pub fn parseBUILTINIDENTIFIER(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsebyte_order_mark

函数

第 3068 行

pub fn parsebyte_order_mark(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseByteAlign

函数

第 2880 行

pub fn parseByteAlign(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCallConv

函数

第 1856 行

pub fn parseCallConv(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCARET

函数

第 4382 行

pub fn parseCARET(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCARETEQUAL

函数

第 4412 行

pub fn parseCARETEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsechar_char

函数

第 3429 行

pub fn parsechar_char(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCHAR_LITERAL

函数

第 3848 行

pub fn parseCHAR_LITERAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCOLON

函数

第 4430 行

pub fn parseCOLON(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCOMMA

函数

第 4448 行

pub fn parseCOMMA(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCompareExpr

函数

第 1030 行

pub fn parseCompareExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCompareOp

函数

第 2216 行

pub fn parseCompareOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCompareOpTok

函数

第 2240 行

pub fn parseCompareOpTok(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseComptimeDecl

函数

第 407 行

pub fn parseComptimeDecl(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsecontainer_doc_comment

函数

第 3509 行

pub fn parsecontainer_doc_comment(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseContainerDecl

函数

第 356 行

pub fn parseContainerDecl(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseContainerDeclPrefix

函数

第 372 行

pub fn parseContainerDeclPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseContainerField

函数

第 550 行

pub fn parseContainerField(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseContainerMembers

函数

第 306 行

pub fn parseContainerMembers(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseContainerMembersRest

函数

第 325 行

pub fn parseContainerMembersRest(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseContainerType

函数

第 1543 行

pub fn parseContainerType(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseContainerTypeAuto

函数

第 2823 行

pub fn parseContainerTypeAuto(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseContainerTypeKind

函数

第 2835 行

pub fn parseContainerTypeKind(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseCurlySuffixExpr

函数

第 1363 行

pub fn parseCurlySuffixExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseDecl

函数

第 419 行

pub fn parseDecl(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseDeclPrefix

函数

第 458 行

pub fn parseDeclPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsedigit

函数

第 3881 行

pub fn parsedigit(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsedigit_float

函数

第 3931 行

pub fn parsedigit_float(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsedigit_int

函数

第 3907 行

pub fn parsedigit_int(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsedoc_comment

函数

第 3548 行

pub fn parsedoc_comment(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseDOT

函数

第 4466 行

pub fn parseDOT(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseDOT2

函数

第 4497 行

pub fn parseDOT2(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseDOT3

函数

第 4527 行

pub fn parseDOT3(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseDOTASTERISK

函数

第 4545 行

pub fn parseDOTASTERISK(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseend_of_word

函数

第 5595 行

pub fn parseend_of_word(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseeof

函数

第 3098 行

pub fn parseeof(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseEQUAL

函数

第 4563 行

pub fn parseEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseEQUALEQUAL

函数

第 4594 行

pub fn parseEQUALEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseEQUALRARROW

函数

第 4612 行

pub fn parseEQUALRARROW(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseErrorSetDecl

函数

第 1562 行

pub fn parseErrorSetDecl(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseErrorUnionExpr

函数

第 1451 行

pub fn parseErrorUnionExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseEXCLAMATIONMARK

函数

第 4630 行

pub fn parseEXCLAMATIONMARK(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseEXCLAMATIONMARKEQUAL

函数

第 4660 行

pub fn parseEXCLAMATIONMARKEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseExpr

函数

第 960 行

pub fn parseExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseExprList

函数

第 3032 行

pub fn parseExprList(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseExprPrefix

函数

第 3056 行

pub fn parseExprPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseFieldInit

函数

第 1808 行

pub fn parseFieldInit(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseFnCallArguments

函数

第 2741 行

pub fn parseFnCallArguments(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseFnProto

函数

第 497 行

pub fn parseFnProto(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseForArgumentsList

函数

第 2062 行

pub fn parseForArgumentsList(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseForExpr

函数

第 1322 行

pub fn parseForExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseForItem

函数

第 2086 行

pub fn parseForItem(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseForPrefix

函数

第 1930 行

pub fn parseForPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseForStatement

函数

第 734 行

pub fn parseForStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseForTypeExpr

函数

第 1645 行

pub fn parseForTypeExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseGlobalVarDecl

函数

第 533 行

pub fn parseGlobalVarDecl(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseGroupedExpr

函数

第 1574 行

pub fn parseGroupedExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseIDENTIFIER

函数

第 4093 行

pub fn parseIDENTIFIER(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseIdentifierList

函数

第 2909 行

pub fn parseIdentifierList(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseIfExpr

函数

第 1260 行

pub fn parseIfExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseIfPrefix

函数

第 1906 行

pub fn parseIfPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseIfStatement

函数

第 656 行

pub fn parseIfStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseIfTypeExpr

函数

第 1586 行

pub fn parseIfTypeExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseInitList

函数

第 1387 行

pub fn parseInitList(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsekeyword

函数

第 6450 行

pub fn parsekeyword(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_addrspace

函数

第 5622 行

pub fn parseKEYWORD_addrspace(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_align

函数

第 5640 行

pub fn parseKEYWORD_align(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_allowzero

函数

第 5658 行

pub fn parseKEYWORD_allowzero(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_and

函数

第 5676 行

pub fn parseKEYWORD_and(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_anyframe

函数

第 5694 行

pub fn parseKEYWORD_anyframe(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_anytype

函数

第 5712 行

pub fn parseKEYWORD_anytype(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_asm

函数

第 5730 行

pub fn parseKEYWORD_asm(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_break

函数

第 5748 行

pub fn parseKEYWORD_break(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_callconv

函数

第 5766 行

pub fn parseKEYWORD_callconv(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_catch

函数

第 5784 行

pub fn parseKEYWORD_catch(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_comptime

函数

第 5802 行

pub fn parseKEYWORD_comptime(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_const

函数

第 5820 行

pub fn parseKEYWORD_const(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_continue

函数

第 5838 行

pub fn parseKEYWORD_continue(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_defer

函数

第 5856 行

pub fn parseKEYWORD_defer(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_else

函数

第 5874 行

pub fn parseKEYWORD_else(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_enum

函数

第 5892 行

pub fn parseKEYWORD_enum(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_errdefer

函数

第 5910 行

pub fn parseKEYWORD_errdefer(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_error

函数

第 5928 行

pub fn parseKEYWORD_error(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_export

函数

第 5946 行

pub fn parseKEYWORD_export(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_extern

函数

第 5964 行

pub fn parseKEYWORD_extern(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_fn

函数

第 5982 行

pub fn parseKEYWORD_fn(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_for

函数

第 6000 行

pub fn parseKEYWORD_for(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_if

函数

第 6018 行

pub fn parseKEYWORD_if(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_inline

函数

第 6036 行

pub fn parseKEYWORD_inline(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_linksection

函数

第 6234 行

pub fn parseKEYWORD_linksection(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_noalias

函数

第 6054 行

pub fn parseKEYWORD_noalias(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_noinline

函数

第 6090 行

pub fn parseKEYWORD_noinline(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_nosuspend

函数

第 6072 行

pub fn parseKEYWORD_nosuspend(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_opaque

函数

第 6108 行

pub fn parseKEYWORD_opaque(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_or

函数

第 6126 行

pub fn parseKEYWORD_or(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_orelse

函数

第 6144 行

pub fn parseKEYWORD_orelse(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_packed

函数

第 6162 行

pub fn parseKEYWORD_packed(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_pub

函数

第 6180 行

pub fn parseKEYWORD_pub(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_resume

函数

第 6198 行

pub fn parseKEYWORD_resume(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_return

函数

第 6216 行

pub fn parseKEYWORD_return(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_struct

函数

第 6252 行

pub fn parseKEYWORD_struct(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_suspend

函数

第 6270 行

pub fn parseKEYWORD_suspend(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_switch

函数

第 6288 行

pub fn parseKEYWORD_switch(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_test

函数

第 6306 行

pub fn parseKEYWORD_test(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_threadlocal

函数

第 6324 行

pub fn parseKEYWORD_threadlocal(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_try

函数

第 6342 行

pub fn parseKEYWORD_try(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_union

函数

第 6360 行

pub fn parseKEYWORD_union(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_unreachable

函数

第 6378 行

pub fn parseKEYWORD_unreachable(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_var

函数

第 6396 行

pub fn parseKEYWORD_var(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_volatile

函数

第 6414 行

pub fn parseKEYWORD_volatile(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseKEYWORD_while

函数

第 6432 行

pub fn parseKEYWORD_while(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLabeledStatement

函数

第 694 行

pub fn parseLabeledStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLabeledTypeExpr

函数

第 1610 行

pub fn parseLabeledTypeExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLARROW

函数

第 4678 行

pub fn parseLARROW(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLARROW2

函数

第 4709 行

pub fn parseLARROW2(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLARROW2EQUAL

函数

第 4740 行

pub fn parseLARROW2EQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLARROW2PIPE

函数

第 4758 行

pub fn parseLARROW2PIPE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLARROW2PIPEEQUAL

函数

第 4788 行

pub fn parseLARROW2PIPEEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLARROWEQUAL

函数

第 4806 行

pub fn parseLARROWEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLBRACE

函数

第 4824 行

pub fn parseLBRACE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLBRACKET

函数

第 4842 行

pub fn parseLBRACKET(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLETTERC

函数

第 5323 行

pub fn parseLETTERC(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseline_comment

函数

第 3594 行

pub fn parseline_comment(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseline_string

函数

第 3647 行

pub fn parseline_string(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLinkSection

函数

第 1832 行

pub fn parseLinkSection(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLoopExpr

函数

第 1303 行

pub fn parseLoopExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLoopStatement

函数

第 715 行

pub fn parseLoopStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLoopTypeExpr

函数

第 1626 行

pub fn parseLoopTypeExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseLPAREN

函数

第 4860 行

pub fn parseLPAREN(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseManyPtrTypeStart

函数

第 2782 行

pub fn parseManyPtrTypeStart(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMINUS

函数

第 4878 行

pub fn parseMINUS(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMINUSEQUAL

函数

第 4911 行

pub fn parseMINUSEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMINUSPERCENT

函数

第 4929 行

pub fn parseMINUSPERCENT(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMINUSPERCENTEQUAL

函数

第 4959 行

pub fn parseMINUSPERCENTEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMINUSPIPE

函数

第 4977 行

pub fn parseMINUSPIPE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMINUSPIPEEQUAL

函数

第 5007 行

pub fn parseMINUSPIPEEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMINUSRARROW

函数

第 5025 行

pub fn parseMINUSRARROW(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsemultibyte_utf8

函数

第 3364 行

pub fn parsemultibyte_utf8(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMultiplyExpr

函数

第 1139 行

pub fn parseMultiplyExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMultiplyOp

函数

第 2418 行

pub fn parseMultiplyOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseMultiplyOpTok

函数

第 2442 行

pub fn parseMultiplyOpTok(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsenewline

函数

第 3672 行

pub fn parsenewline(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsenon_control_ascii

函数

第 3390 行

pub fn parsenon_control_ascii(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsenon_control_utf8

函数

第 3409 行

pub fn parsenon_control_utf8(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseNUMBERLITERAL

函数

第 3963 行

pub fn parseNUMBERLITERAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseOrOp

函数

第 2168 行

pub fn parseOrOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseox80_ox8F

函数

第 3158 行

pub fn parseox80_ox8F(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseox80_ox9F

函数

第 3270 行

pub fn parseox80_ox9F(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseox80_oxBF

函数

第 3121 行

pub fn parseox80_oxBF(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseox90_0xBF

函数

第 3214 行

pub fn parseox90_0xBF(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxA0_oxBF

函数

第 3326 行

pub fn parseoxA0_oxBF(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxC2_oxDF

函数

第 3345 行

pub fn parseoxC2_oxDF(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxE0

函数

第 3308 行

pub fn parseoxE0(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxE1_oxEC

函数

第 3289 行

pub fn parseoxE1_oxEC(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxED

函数

第 3252 行

pub fn parseoxED(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxEE_oxEF

函数

第 3233 行

pub fn parseoxEE_oxEF(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxF0

函数

第 3196 行

pub fn parseoxF0(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxF1_oxF3

函数

第 3177 行

pub fn parseoxF1_oxF3(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseoxF4

函数

第 3140 行

pub fn parseoxF4(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseParamDecl

函数

第 1868 行

pub fn parseParamDecl(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseParamDeclList

函数

第 2997 行

pub fn parseParamDeclList(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseParamDeclListRest

函数

第 3009 行

pub fn parseParamDeclListRest(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseParamType

函数

第 1892 行

pub fn parseParamType(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePayload

函数

第 1942 行

pub fn parsePayload(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePERCENT

函数

第 5043 行

pub fn parsePERCENT(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePERCENTEQUAL

函数

第 5073 行

pub fn parsePERCENTEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePIPE

函数

第 5091 行

pub fn parsePIPE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePIPE2

函数

第 5122 行

pub fn parsePIPE2(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePIPEEQUAL

函数

第 5140 行

pub fn parsePIPEEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePLUS

函数

第 5158 行

pub fn parsePLUS(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePLUS2

函数

第 5191 行

pub fn parsePLUS2(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePLUSEQUAL

函数

第 5209 行

pub fn parsePLUSEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePLUSPERCENT

函数

第 5227 行

pub fn parsePLUSPERCENT(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePLUSPERCENTEQUAL

函数

第 5257 行

pub fn parsePLUSPERCENTEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePLUSPIPE

函数

第 5275 行

pub fn parsePLUSPIPE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePLUSPIPEEQUAL

函数

第 5305 行

pub fn parsePLUSPIPEEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsepost_op_white

函数

第 3826 行

pub fn parsepost_op_white(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsepre_op_white

函数

第 3788 行

pub fn parsepre_op_white(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePrefixExpr

函数

第 1168 行

pub fn parsePrefixExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePrefixOp

函数

第 2464 行

pub fn parsePrefixOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePrefixTypeOp

函数

第 2486 行

pub fn parsePrefixTypeOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePrefixTypeOpPrefix

函数

第 2661 行

pub fn parsePrefixTypeOpPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePrimaryExpr

函数

第 1192 行

pub fn parsePrimaryExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePrimaryTypeExpr

函数

第 1499 行

pub fn parsePrimaryTypeExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePtrIndexPayload

函数

第 1966 行

pub fn parsePtrIndexPayload(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePtrListPayload

函数

第 1983 行

pub fn parsePtrListPayload(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePtrMod

函数

第 2645 行

pub fn parsePtrMod(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePtrMods

函数

第 2513 行

pub fn parsePtrMods(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsePtrPayload

函数

第 1954 行

pub fn parsePtrPayload(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseQUESTIONMARK

函数

第 5341 行

pub fn parseQUESTIONMARK(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseRARROW

函数

第 5359 行

pub fn parseRARROW(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseRARROW2

函数

第 5390 行

pub fn parseRARROW2(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseRARROW2EQUAL

函数

第 5420 行

pub fn parseRARROW2EQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseRARROWEQUAL

函数

第 5438 行

pub fn parseRARROWEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseRBRACE

函数

第 5456 行

pub fn parseRBRACE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseRBRACKET

函数

第 5474 行

pub fn parseRBRACKET(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseRoot

函数

第 294 行

pub fn parseRoot(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseRPAREN

函数

第 5492 行

pub fn parseRPAREN(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSEMICOLON

函数

第 5510 行

pub fn parseSEMICOLON(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSingleAssignExpr

函数

第 936 行

pub fn parseSingleAssignExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSinglePtrMods

函数

第 2579 行

pub fn parseSinglePtrMods(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSinglePtrTypeStart

函数

第 2770 行

pub fn parseSinglePtrTypeStart(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseskip

函数

第 3710 行

pub fn parseskip(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseskip_require_newline

函数

第 3746 行

pub fn parseskip_require_newline(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSLASH

函数

第 5528 行

pub fn parseSLASH(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSLASHEQUAL

函数

第 5559 行

pub fn parseSLASHEQUAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSliceTypeStart

函数

第 2753 行

pub fn parseSliceTypeStart(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsesof

函数

第 3086 行

pub fn parsesof(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseStatement

函数

第 595 行

pub fn parseStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseStatementPrefix

函数

第 622 行

pub fn parseStatementPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsestring

函数

第 4020 行

pub fn parsestring(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parsestring_char

函数

第 3469 行

pub fn parsestring_char(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSTRINGLITERAL

函数

第 4065 行

pub fn parseSTRINGLITERAL(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSTRINGLITERALSINGLE

函数

第 4053 行

pub fn parseSTRINGLITERALSINGLE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSuffixExpr

函数

第 1475 行

pub fn parseSuffixExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSuffixOp

函数

第 2679 行

pub fn parseSuffixOp(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSuffixOpPrefix

函数

第 2721 行

pub fn parseSuffixOpPrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSwitchCase

函数

第 2019 行

pub fn parseSwitchCase(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSwitchExpr

函数

第 1693 行

pub fn parseSwitchExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSwitchItem

函数

第 2045 行

pub fn parseSwitchItem(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSwitchProng

函数

第 2007 行

pub fn parseSwitchProng(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseSwitchProngList

函数

第 2931 行

pub fn parseSwitchProngList(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseTestDecl

函数

第 388 行

pub fn parseTestDecl(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseTILDE

函数

第 5577 行

pub fn parseTILDE(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseTypeExpr

函数

第 1427 行

pub fn parseTypeExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseVarAssignStatement

函数

第 853 行

pub fn parseVarAssignStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseVarDeclProto

函数

第 509 行

pub fn parseVarDeclProto(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseWhileContinueExpr

函数

第 1820 行

pub fn parseWhileContinueExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseWhileExpr

函数

第 1346 行

pub fn parseWhileExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseWhilePrefix

函数

第 1918 行

pub fn parseWhilePrefix(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseWhileStatement

函数

第 772 行

pub fn parseWhileStatement(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.Parser.parseWhileTypeExpr

函数

第 1669 行

pub fn parseWhileTypeExpr(p: *Parser) Error!bool

参数

p: *Parser

错误

MaxDepth

std.zig.parser_generated_oracle.std

别名

第 4 行

别名目标 std

源码

std/zig/parser_generated_oracle.zig

//! 此文件自动生成,请勿手动编辑!生成命令:
//! zig build gen-parser-oracle

const std = @import("std");

const Error = error{MaxDepth};
const max_depth = 5;

/// 若输入源属于语法定义的语言,返回 true。
/// 递归/迭代层数超过 `max_depth` 时,返回 error.MaxDepth。
///
pub fn parse(source: []const u8) Error!bool {
    var p: Parser = .{ .source = source, .i = 0, .depths = @splat(1) };
    return p.parseRoot();
}
const Def = enum {
    defRoot,
    defContainerMembers,
    defContainerMembersRest,
    defContainerDecl,
    defContainerDeclPrefix,
    defTestDecl,
    defComptimeDecl,
    defDecl,
    defDeclPrefix,
    defFnProto,
    defVarDeclProto,
    defGlobalVarDecl,
    defContainerField,
    defBlockStatement,
    defStatement,
    defStatementPrefix,
    defIfStatement,
    defLabeledStatement,
    defLoopStatement,
    defForStatement,
    defWhileStatement,
    defBlockExprStatement,
    defBlockExprPrefix,
    defBlockExpr,
    defVarAssignStatement,
    defAssignExpr,
    defSingleAssignExpr,
    defExpr,
    defBoolOrExpr,
    defBoolAndExpr,
    defCompareExpr,
    defBitwiseExpr,
    defBitShiftExpr,
    defAdditionExpr,
    defMultiplyExpr,
    defPrefixExpr,
    defPrimaryExpr,
    defIfExpr,
    defBlock,
    defLoopExpr,
    defForExpr,
    defWhileExpr,
    defCurlySuffixExpr,
    defInitList,
    defTypeExpr,
    defErrorUnionExpr,
    defSuffixExpr,
    defPrimaryTypeExpr,
    defContainerType,
    defErrorSetDecl,
    defGroupedExpr,
    defIfTypeExpr,
    defLabeledTypeExpr,
    defLoopTypeExpr,
    defForTypeExpr,
    defWhileTypeExpr,
    defSwitchExpr,
    defAsmExpr,
    defAsmOutput,
    defAsmOutputItem,
    defAsmInput,
    defAsmInputItem,
    defAsmClobbers,
    defBreakLabel,
    defBlockLabel,
    defFieldInit,
    defWhileContinueExpr,
    defLinkSection,
    defAddrSpace,
    defCallConv,
    defParamDecl,
    defParamType,
    defIfPrefix,
    defWhilePrefix,
    defForPrefix,
    defPayload,
    defPtrPayload,
    defPtrIndexPayload,
    defPtrListPayload,
    defSwitchProng,
    defSwitchCase,
    defSwitchItem,
    defForArgumentsList,
    defForItem,
    defAssignOp,
    defOrOp,
    defAndOp,
    defCompareOp,
    defCompareOpTok,
    defBitwiseOp,
    defBitwiseOpTok,
    defBitShiftOp,
    defBitShiftOpTok,
    defAdditionOp,
    defAdditionOpTok,
    defMultiplyOp,
    defMultiplyOpTok,
    defPrefixOp,
    defPrefixTypeOp,
    defPtrMods,
    defSinglePtrMods,
    defPtrMod,
    defPrefixTypeOpPrefix,
    defSuffixOp,
    defSuffixOpPrefix,
    defFnCallArguments,
    defSliceTypeStart,
    defSinglePtrTypeStart,
    defManyPtrTypeStart,
    defArrayTypeStart,
    defContainerTypeAuto,
    defContainerTypeKind,
    defByteAlign,
    defBitAlign,
    defIdentifierList,
    defSwitchProngList,
    defAsmOutputList,
    defAsmInputList,
    defParamDeclList,
    defParamDeclListRest,
    defExprList,
    defExprPrefix,
    defbyte_order_mark,
    defsof,
    defeof,
    defox80_oxBF,
    defoxF4,
    defox80_ox8F,
    defoxF1_oxF3,
    defoxF0,
    defox90_0xBF,
    defoxEE_oxEF,
    defoxED,
    defox80_ox9F,
    defoxE1_oxEC,
    defoxE0,
    defoxA0_oxBF,
    defoxC2_oxDF,
    defmultibyte_utf8,
    defnon_control_ascii,
    defnon_control_utf8,
    defchar_char,
    defstring_char,
    defcontainer_doc_comment,
    defdoc_comment,
    defline_comment,
    defline_string,
    defnewline,
    defskip,
    defskip_require_newline,
    defpre_op_white,
    defpost_op_white,
    defCHAR_LITERAL,
    defdigit,
    defdigit_int,
    defdigit_float,
    defNUMBERLITERAL,
    defstring,
    defSTRINGLITERALSINGLE,
    defSTRINGLITERAL,
    defIDENTIFIER,
    defBUILTINIDENTIFIER,
    defAMPERSAND,
    defAMPERSANDEQUAL,
    defASTERISK,
    defASTERISKEQUAL,
    defASTERISKPERCENT,
    defASTERISKPERCENTEQUAL,
    defASTERISKPIPE,
    defASTERISKPIPEEQUAL,
    defCARET,
    defCARETEQUAL,
    defCOLON,
    defCOMMA,
    defDOT,
    defDOT2,
    defDOT3,
    defDOTASTERISK,
    defEQUAL,
    defEQUALEQUAL,
    defEQUALRARROW,
    defEXCLAMATIONMARK,
    defEXCLAMATIONMARKEQUAL,
    defLARROW,
    defLARROW2,
    defLARROW2EQUAL,
    defLARROW2PIPE,
    defLARROW2PIPEEQUAL,
    defLARROWEQUAL,
    defLBRACE,
    defLBRACKET,
    defLPAREN,
    defMINUS,
    defMINUSEQUAL,
    defMINUSPERCENT,
    defMINUSPERCENTEQUAL,
    defMINUSPIPE,
    defMINUSPIPEEQUAL,
    defMINUSRARROW,
    defPERCENT,
    defPERCENTEQUAL,
    defPIPE,
    defPIPE2,
    defPIPEEQUAL,
    defPLUS,
    defPLUS2,
    defPLUSEQUAL,
    defPLUSPERCENT,
    defPLUSPERCENTEQUAL,
    defPLUSPIPE,
    defPLUSPIPEEQUAL,
    defLETTERC,
    defQUESTIONMARK,
    defRARROW,
    defRARROW2,
    defRARROW2EQUAL,
    defRARROWEQUAL,
    defRBRACE,
    defRBRACKET,
    defRPAREN,
    defSEMICOLON,
    defSLASH,
    defSLASHEQUAL,
    defTILDE,
    defend_of_word,
    defKEYWORD_addrspace,
    defKEYWORD_align,
    defKEYWORD_allowzero,
    defKEYWORD_and,
    defKEYWORD_anyframe,
    defKEYWORD_anytype,
    defKEYWORD_asm,
    defKEYWORD_break,
    defKEYWORD_callconv,
    defKEYWORD_catch,
    defKEYWORD_comptime,
    defKEYWORD_const,
    defKEYWORD_continue,
    defKEYWORD_defer,
    defKEYWORD_else,
    defKEYWORD_enum,
    defKEYWORD_errdefer,
    defKEYWORD_error,
    defKEYWORD_export,
    defKEYWORD_extern,
    defKEYWORD_fn,
    defKEYWORD_for,
    defKEYWORD_if,
    defKEYWORD_inline,
    defKEYWORD_noalias,
    defKEYWORD_nosuspend,
    defKEYWORD_noinline,
    defKEYWORD_opaque,
    defKEYWORD_or,
    defKEYWORD_orelse,
    defKEYWORD_packed,
    defKEYWORD_pub,
    defKEYWORD_resume,
    defKEYWORD_return,
    defKEYWORD_linksection,
    defKEYWORD_struct,
    defKEYWORD_suspend,
    defKEYWORD_switch,
    defKEYWORD_test,
    defKEYWORD_threadlocal,
    defKEYWORD_try,
    defKEYWORD_union,
    defKEYWORD_unreachable,
    defKEYWORD_var,
    defKEYWORD_volatile,
    defKEYWORD_while,
    defkeyword,
};
const Parser = struct {
    source: []const u8,
    i: usize,
    depths: [272]u8,
    pub fn parseRoot(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defRoot);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseContainerMembers() and try p.parseskip() and try p.parseeof()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseContainerMembers(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defContainerMembers);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parsecontainer_doc_comment() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parseContainerDecl()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and try p.parseContainerMembersRest()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseContainerMembersRest(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defContainerMembersRest);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseContainerDeclPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseContainerField() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseCOMMA() and try p.parseContainerMembersRest()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                var i_1: usize = 0;
                while (try p.parseContainerDecl()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseContainerDecl(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defContainerDecl);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseTestDecl()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseComptimeDecl()) break :blk_0 true;
            p.i = pos_0;
            if ((try p.parsedoc_comment() or true) and (try p.parseKEYWORD_pub() or true) and try p.parseDecl()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseContainerDeclPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defContainerDeclPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_test()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_comptime() and try p.parseLBRACE()) break :blk_0 true;
            p.i = pos_0;
            if ((try p.parsedoc_comment() or true) and (try p.parseKEYWORD_pub() or true) and try p.parseDeclPrefix()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseTestDecl(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defTestDecl);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_test() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseSTRINGLITERALSINGLE()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseIDENTIFIER()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseBlock()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseComptimeDecl(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defComptimeDecl);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_comptime() and try p.parseBlock()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseDecl(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defDecl);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((blk_3: {
                const pos_3 = p.i;
                if (try p.parseKEYWORD_export()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseKEYWORD_inline()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseKEYWORD_noinline()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseFnProto() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseSEMICOLON()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseBlock()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_extern() and (try p.parseSTRINGLITERALSINGLE() or true) and try p.parseFnProto() and try p.parseSEMICOLON()) break :blk_0 true;
            p.i = pos_0;
            if ((blk_3: {
                const pos_3 = p.i;
                if (try p.parseKEYWORD_export()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseKEYWORD_extern() and (try p.parseSTRINGLITERALSINGLE() or true)) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and (try p.parseKEYWORD_threadlocal() or true) and try p.parseGlobalVarDecl()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseDeclPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defDeclPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((blk_3: {
                const pos_3 = p.i;
                if (try p.parseKEYWORD_export()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseKEYWORD_inline()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseKEYWORD_noinline()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseKEYWORD_fn()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_extern() and (try p.parseSTRINGLITERALSINGLE() or true) and try p.parseKEYWORD_fn()) break :blk_0 true;
            p.i = pos_0;
            if ((blk_3: {
                const pos_3 = p.i;
                if (try p.parseKEYWORD_export()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseKEYWORD_extern() and (try p.parseSTRINGLITERALSINGLE() or true)) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and (try p.parseKEYWORD_threadlocal() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_const()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseKEYWORD_var()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseFnProto(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defFnProto);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_fn() and (try p.parseIDENTIFIER() or true) and try p.parseParamDeclList() and (try p.parseByteAlign() or true) and (try p.parseAddrSpace() or true) and (try p.parseLinkSection() or true) and (try p.parseCallConv() or true) and (try p.parseEXCLAMATIONMARK() or true) and try p.parseTypeExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseVarDeclProto(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defVarDeclProto);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_const()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseKEYWORD_var()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            } and try p.parseIDENTIFIER() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseCOLON() and try p.parseTypeExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and (try p.parseByteAlign() or true) and (try p.parseAddrSpace() or true) and (try p.parseLinkSection() or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseGlobalVarDecl(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defGlobalVarDecl);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseVarDeclProto() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseEQUAL() and try p.parseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseSEMICOLON()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseContainerField(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defContainerField);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parsedoc_comment() or true) and (try p.parseKEYWORD_comptime() or true) and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseIDENTIFIER() and try p.parseCOLON()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseTypeExpr() and (try p.parseByteAlign() or true) and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseEQUAL() and try p.parseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBlockStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBlockStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseStatement()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_defer() and try p.parseBlockExprStatement()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_errdefer() and try p.parseBlockExprStatement()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseStatementPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and (try p.parseKEYWORD_comptime() or true) and try p.parseVarAssignStatement()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseIfStatement()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLabeledStatement()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_nosuspend() and try p.parseBlockExprStatement()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_comptime() and try p.parseBlockExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_suspend() and try p.parseBlockExprStatement()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseStatementPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and (try p.parseKEYWORD_comptime() or true) and try p.parseAssignExpr() and try p.parseSEMICOLON()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseStatementPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defStatementPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_if()) break :blk_0 true;
            p.i = pos_0;
            if ((try p.parseBlockLabel() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseLBRACE()) break :blk_2 true;
                p.i = pos_2;
                if ((try p.parseKEYWORD_inline() or true) and blk_4: {
                    const pos_4 = p.i;
                    if (try p.parseKEYWORD_for()) break :blk_4 true;
                    p.i = pos_4;
                    if (try p.parseKEYWORD_while()) break :blk_4 true;
                    p.i = pos_4;
                    break :blk_4 false;
                }) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseKEYWORD_switch()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_nosuspend()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_comptime() and try p.parseBlockExprPrefix()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseIfStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defIfStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseIfPrefix() and try p.parseBlockExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseStatement()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseKEYWORD_else();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseIfPrefix() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseBlockExprPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseAssignExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseSEMICOLON()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseStatement()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLabeledStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLabeledStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parseBlockLabel() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseBlock()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseLoopStatement()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseSwitchExpr()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLoopStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLoopStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parseKEYWORD_inline() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseForStatement()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseWhileStatement()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseForStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defForStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseForPrefix() and try p.parseBlockExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_else() and try p.parseStatement()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseKEYWORD_else();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseForPrefix() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseBlockExprPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseAssignExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseSEMICOLON()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseKEYWORD_else() and try p.parseStatement()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseWhileStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defWhileStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseWhilePrefix() and try p.parseBlockExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseStatement()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseKEYWORD_else();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseWhilePrefix() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseBlockExprPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseAssignExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseSEMICOLON()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseStatement()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBlockExprStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBlockExprStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseBlockExpr()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseBlockExprPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseAssignExpr() and try p.parseSEMICOLON()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBlockExprPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBlockExprPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parseBlockLabel() or true) and try p.parseLBRACE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBlockExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBlockExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parseBlockLabel() or true) and try p.parseBlock()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseVarAssignStatement(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defVarAssignStatement);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_2: {
                const pos_2 = p.i;
                if (try p.parseVarDeclProto()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            } and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseCOMMA() and blk_5: {
                        const pos_5 = p.i;
                        if (try p.parseVarDeclProto()) break :blk_5 true;
                        p.i = pos_5;
                        if (try p.parseExpr()) break :blk_5 true;
                        p.i = pos_5;
                        break :blk_5 false;
                    }) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and try p.parseEQUAL() and try p.parseExpr() and try p.parseSEMICOLON()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAssignExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAssignExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseAssignOp() and try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    var match_3 = false;
                    var i_3: usize = 0;
                    while (blk_5: {
                        const pos_5 = p.i;
                        if (try p.parseCOMMA() and try p.parseExpr()) break :blk_5 true;
                        p.i = pos_5;
                        break :blk_5 false;
                    }) {
                        match_3 = true;
                        if (i_3 > max_depth) return error.MaxDepth;
                        i_3 += 1;
                    }
                    break :blk_3 match_3;
                } and try p.parseEQUAL() and try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseAssignOp();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                } and blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseCOMMA();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSingleAssignExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSingleAssignExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseAssignOp() and try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseAssignOp();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseBoolOrExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBoolOrExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBoolOrExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseBoolAndExpr() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseOrOp() and try p.parseBoolAndExpr()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseOrOp();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBoolAndExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBoolAndExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseCompareExpr() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseAndOp() and try p.parseCompareExpr()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseAndOp();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCompareExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCompareExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseBitwiseExpr() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseCompareOp() and try p.parseBitwiseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseCompareOp();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBitwiseExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBitwiseExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseBitShiftExpr() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseBitwiseOp() and try p.parseBitShiftExpr()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseBitwiseOp();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBitShiftExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBitShiftExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseAdditionExpr() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseBitShiftOp() and try p.parseAdditionExpr()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseBitShiftOp();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAdditionExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAdditionExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseMultiplyExpr() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseAdditionOp() and try p.parseMultiplyExpr()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseAdditionOp();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMultiplyExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMultiplyExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsePrefixExpr() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseMultiplyOp() and try p.parsePrefixExpr()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseMultiplyOp();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePrefixExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPrefixExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                var i_1: usize = 0;
                while (try p.parsePrefixOp()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsePrefixOp();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parsePrimaryExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePrimaryExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPrimaryExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseAsmExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseIfExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_break() and (try p.parseBreakLabel() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseExprPrefix();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_comptime() and try p.parseExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_nosuspend() and try p.parseExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_continue() and (try p.parseBreakLabel() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseExprPrefix();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_resume() and try p.parseExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_return() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseExprPrefix();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if ((try p.parseBlockLabel() or true) and try p.parseLoopExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseBlock()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseCurlySuffixExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseIfExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defIfExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseIfPrefix() and try p.parseExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseKEYWORD_else();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBlock(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBlock);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACE() and blk_1: {
                var i_1: usize = 0;
                while (try p.parseBlockStatement()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and try p.parseRBRACE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLoopExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLoopExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parseKEYWORD_inline() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseForExpr()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseWhileExpr()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseForExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defForExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseForPrefix() and try p.parseExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_else() and try p.parseExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseKEYWORD_else();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseWhileExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defWhileExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseWhilePrefix() and try p.parseExpr() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCurlySuffixExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCurlySuffixExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseTypeExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseInitList()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseLBRACE();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseInitList(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defInitList);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACE() and try p.parseFieldInit() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseCOMMA() and try p.parseFieldInit()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseCOMMA() or true) and try p.parseRBRACE()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLBRACE() and try p.parseExpr() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseCOMMA() and try p.parseExpr()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseCOMMA() or true) and try p.parseRBRACE()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLBRACE() and try p.parseRBRACE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseTypeExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defTypeExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                var i_1: usize = 0;
                while (try p.parsePrefixTypeOp()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsePrefixTypeOpPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseErrorUnionExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseErrorUnionExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defErrorUnionExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseSuffixExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseEXCLAMATIONMARK() and try p.parseTypeExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseEXCLAMATIONMARK();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSuffixExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSuffixExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsePrimaryTypeExpr() and blk_1: {
                var i_1: usize = 0;
                while (try p.parseSuffixOp()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseSuffixOpPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePrimaryTypeExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPrimaryTypeExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseBUILTINIDENTIFIER() and try p.parseFnCallArguments()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseCHAR_LITERAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseContainerType()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOT() and try p.parseIDENTIFIER()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOT() and try p.parseInitList()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseErrorSetDecl()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseFnProto()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseGroupedExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLabeledTypeExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseIDENTIFIER()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseIfTypeExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_comptime() and try p.parseTypeExpr()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_error() and try p.parseDOT() and try p.parseIDENTIFIER()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_anyframe()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_unreachable()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseNUMBERLITERAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseSTRINGLITERAL()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseContainerType(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defContainerType);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((blk_3: {
                const pos_3 = p.i;
                if (try p.parseKEYWORD_extern()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseKEYWORD_packed()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseContainerTypeAuto()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseErrorSetDecl(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defErrorSetDecl);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_error() and try p.parseLBRACE() and try p.parseIdentifierList() and try p.parseRBRACE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseGroupedExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defGroupedExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseIfTypeExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defIfTypeExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseIfPrefix() and try p.parseTypeExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseTypeExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseKEYWORD_else();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLabeledTypeExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLabeledTypeExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseBlockLabel() and try p.parseBlock()) break :blk_0 true;
            p.i = pos_0;
            if ((try p.parseBlockLabel() or true) and try p.parseLoopTypeExpr()) break :blk_0 true;
            p.i = pos_0;
            if ((try p.parseBlockLabel() or true) and try p.parseSwitchExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLoopTypeExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLoopTypeExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parseKEYWORD_inline() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseForTypeExpr()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseWhileTypeExpr()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseForTypeExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defForTypeExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseForPrefix() and try p.parseTypeExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_else() and try p.parseTypeExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseKEYWORD_else();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseWhileTypeExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defWhileTypeExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseWhilePrefix() and try p.parseTypeExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_else() and (try p.parsePayload() or true) and try p.parseTypeExpr()) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseKEYWORD_else();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSwitchExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSwitchExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_switch() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN() and try p.parseLBRACE() and try p.parseSwitchProngList() and try p.parseRBRACE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAsmExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAsmExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_asm() and (try p.parseKEYWORD_volatile() or true) and try p.parseLPAREN() and try p.parseExpr() and (try p.parseAsmOutput() or true) and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAsmOutput(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAsmOutput);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseCOLON() and try p.parseAsmOutputList() and (try p.parseAsmInput() or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAsmOutputItem(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAsmOutputItem);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACKET() and try p.parseIDENTIFIER() and try p.parseRBRACKET() and try p.parseSTRINGLITERALSINGLE() and try p.parseLPAREN() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseMINUSRARROW() and try p.parseTypeExpr()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseIDENTIFIER()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            } and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAsmInput(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAsmInput);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseCOLON() and try p.parseAsmInputList() and (try p.parseAsmClobbers() or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAsmInputItem(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAsmInputItem);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACKET() and try p.parseIDENTIFIER() and try p.parseRBRACKET() and try p.parseSTRINGLITERALSINGLE() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAsmClobbers(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAsmClobbers);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseCOLON() and try p.parseExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBreakLabel(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBreakLabel);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseCOLON() and try p.parseIDENTIFIER()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBlockLabel(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBlockLabel);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseIDENTIFIER() and try p.parseCOLON()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseFieldInit(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defFieldInit);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseDOT() and try p.parseIDENTIFIER() and try p.parseEQUAL() and try p.parseExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseWhileContinueExpr(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defWhileContinueExpr);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseCOLON() and try p.parseLPAREN() and try p.parseAssignExpr() and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLinkSection(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLinkSection);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_linksection() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAddrSpace(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAddrSpace);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_addrspace() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCallConv(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCallConv);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_callconv() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseParamDecl(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defParamDecl);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parsedoc_comment() or true) and blk_2: {
                const pos_2 = p.i;
                if (try p.parseKEYWORD_noalias()) break :blk_2 true;
                p.i = pos_2;
                if ((try p.parseKEYWORD_comptime() or true)) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            } and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseIDENTIFIER() and try p.parseCOLON()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseParamType()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseParamType(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defParamType);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_anytype()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseTypeExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseIfPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defIfPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_if() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN() and (try p.parsePtrPayload() or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseWhilePrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defWhilePrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_while() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN() and (try p.parsePtrPayload() or true) and (try p.parseWhileContinueExpr() or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseForPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defForPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_for() and try p.parseLPAREN() and try p.parseForArgumentsList() and try p.parseRPAREN() and try p.parsePtrListPayload()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePayload(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPayload);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsePIPE() and try p.parseIDENTIFIER() and try p.parsePIPE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePtrPayload(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPtrPayload);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsePIPE() and (try p.parseASTERISK() or true) and try p.parseIDENTIFIER() and try p.parsePIPE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePtrIndexPayload(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPtrIndexPayload);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsePIPE() and (try p.parseASTERISK() or true) and try p.parseIDENTIFIER() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseCOMMA() and try p.parseIDENTIFIER()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parsePIPE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePtrListPayload(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPtrListPayload);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsePIPE() and (try p.parseASTERISK() or true) and try p.parseIDENTIFIER() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseCOMMA() and (try p.parseASTERISK() or true) and try p.parseIDENTIFIER()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseCOMMA() or true) and try p.parsePIPE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSwitchProng(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSwitchProng);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parseKEYWORD_inline() or true) and try p.parseSwitchCase() and try p.parseEQUALRARROW() and (try p.parsePtrIndexPayload() or true) and try p.parseSingleAssignExpr()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSwitchCase(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSwitchCase);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseSwitchItem() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseCOMMA() and try p.parseSwitchItem()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseCOMMA() or true)) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_else()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSwitchItem(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSwitchItem);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseExpr() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseDOT3() and try p.parseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseForArgumentsList(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defForArgumentsList);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseForItem() and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseCOMMA() and try p.parseForItem()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseCOMMA() or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseForItem(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defForItem);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseExpr() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseDOT2() and blk_4: {
                    const pos_4 = p.i;
                    if (try p.parseExpr()) break :blk_4 true;
                    p.i = pos_4;
                    if (blk_5: {
                        const pos_5 = p.i;
                        const match_5 = try p.parseExprPrefix();
                        p.i = pos_5;
                        break :blk_5 !match_5;
                    }) break :blk_4 true;
                    p.i = pos_4;
                    break :blk_4 false;
                }) break :blk_2 true;
                p.i = pos_2;
                if (blk_3: {
                    const pos_3 = p.i;
                    const match_3 = try p.parseDOT2();
                    p.i = pos_3;
                    break :blk_3 !match_3;
                }) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAssignOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAssignOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseASTERISKEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseASTERISKPIPEEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseSLASHEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePERCENTEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePLUSEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePLUSPIPEEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseMINUSEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseMINUSPIPEEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLARROW2EQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLARROW2PIPEEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseRARROW2EQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseAMPERSANDEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseCARETEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePIPEEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseASTERISKPERCENTEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePLUSPERCENTEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseMINUSPERCENTEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseEQUAL()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseOrOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defOrOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsepre_op_white() and try p.parseKEYWORD_or() and try p.parsepost_op_white()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepre_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseKEYWORD_or() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepost_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAndOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAndOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsepre_op_white() and try p.parseKEYWORD_and() and try p.parsepost_op_white()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepre_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseKEYWORD_and() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepost_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCompareOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCompareOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsepre_op_white() and try p.parseCompareOpTok() and try p.parsepost_op_white()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepre_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseCompareOpTok() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepost_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCompareOpTok(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCompareOpTok);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseEQUALEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseEXCLAMATIONMARKEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLARROW()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseRARROW()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLARROWEQUAL()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseRARROWEQUAL()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBitwiseOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBitwiseOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsepre_op_white() and try p.parseBitwiseOpTok() and try p.parsepost_op_white()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepre_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseBitwiseOpTok() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepost_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsepre_op_white() and try p.parseKEYWORD_catch() and try p.parsepost_op_white() and (try p.parsePayload() or true)) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepre_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseKEYWORD_catch() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepost_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and (try p.parsePayload() or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBitwiseOpTok(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBitwiseOpTok);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseAMPERSAND() and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '&'...'&',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseCARET()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePIPE()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_orelse()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBitShiftOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBitShiftOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsepre_op_white() and try p.parseBitShiftOpTok() and try p.parsepost_op_white()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepre_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseBitShiftOpTok() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepost_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBitShiftOpTok(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBitShiftOpTok);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLARROW2()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseRARROW2()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLARROW2PIPE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAdditionOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAdditionOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsepre_op_white() and try p.parseAdditionOpTok() and try p.parsepost_op_white()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepre_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseAdditionOpTok() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepost_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAdditionOpTok(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAdditionOpTok);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsePLUS()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseMINUS()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePLUS2()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePLUSPERCENT()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseMINUSPERCENT()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePLUSPIPE()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseMINUSPIPE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMultiplyOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMultiplyOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsepre_op_white() and try p.parseMultiplyOpTok() and try p.parsepost_op_white()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepre_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseMultiplyOpTok() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsepost_op_white();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMultiplyOpTok(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMultiplyOpTok);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsePIPE2()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseASTERISK()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseSLASH()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parsePERCENT()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseASTERISKPERCENT()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseASTERISKPIPE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePrefixOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPrefixOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseEXCLAMATIONMARK()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseMINUS()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseTILDE()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseMINUSPERCENT()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseAMPERSAND()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_try()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePrefixTypeOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPrefixTypeOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseQUESTIONMARK()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_anyframe() and try p.parseMINUSRARROW()) break :blk_0 true;
            p.i = pos_0;
            if (blk_2: {
                const pos_2 = p.i;
                if (try p.parseManyPtrTypeStart()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseSliceTypeStart()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            } and try p.parsePtrMods()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseSinglePtrTypeStart() and try p.parseSinglePtrMods()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseArrayTypeStart()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePtrMods(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPtrMods);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseKEYWORD_addrspace();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and (try p.parseByteAlign() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseAddrSpace() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseKEYWORD_align();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and (try p.parseAddrSpace() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseByteAlign() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSinglePtrMods(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSinglePtrMods);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseKEYWORD_addrspace();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and (try p.parseBitAlign() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseAddrSpace() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseKEYWORD_align();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and (try p.parseAddrSpace() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (try p.parseBitAlign() or true) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsePtrMod()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePtrMod(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPtrMod);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_allowzero()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_const()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_volatile()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePrefixTypeOpPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPrefixTypeOpPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseQUESTIONMARK()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_anyframe() and try p.parseMINUSRARROW()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLBRACKET()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseASTERISK()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSuffixOp(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSuffixOp);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACKET() and try p.parseExpr() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseDOT2() and blk_5: {
                    const pos_5 = p.i;
                    if (try p.parseExpr()) break :blk_5 true;
                    p.i = pos_5;
                    if (blk_6: {
                        const pos_6 = p.i;
                        const match_6 = try p.parseExprPrefix();
                        p.i = pos_6;
                        break :blk_6 !match_6;
                    }) break :blk_5 true;
                    p.i = pos_5;
                    break :blk_5 false;
                } and (blk_6: {
                    const pos_6 = p.i;
                    if (try p.parseCOLON() and try p.parseExpr()) break :blk_6 true;
                    p.i = pos_6;
                    break :blk_6 false;
                } or true)) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseRBRACKET()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOT() and try p.parseIDENTIFIER()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOTASTERISK()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOT() and try p.parseQUESTIONMARK()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseFnCallArguments()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSuffixOpPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSuffixOpPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACKET()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOT() and try p.parseIDENTIFIER()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOTASTERISK()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOT() and try p.parseQUESTIONMARK()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseLPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseFnCallArguments(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defFnCallArguments);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLPAREN() and try p.parseExprList() and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSliceTypeStart(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSliceTypeStart);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACKET() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseCOLON() and try p.parseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseRBRACKET()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSinglePtrTypeStart(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSinglePtrTypeStart);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseASTERISK()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseManyPtrTypeStart(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defManyPtrTypeStart);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACKET() and try p.parseASTERISK() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseLETTERC()) break :blk_3 true;
                p.i = pos_3;
                if (try p.parseCOLON() and try p.parseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseRBRACKET()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseArrayTypeStart(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defArrayTypeStart);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLBRACKET() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseASTERISK();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parseExpr() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseCOLON() and try p.parseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseRBRACKET()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseContainerTypeAuto(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defContainerTypeAuto);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseContainerTypeKind() and try p.parseLBRACE() and try p.parseContainerMembers() and try p.parseRBRACE()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseContainerTypeKind(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defContainerTypeKind);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_struct() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_opaque()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_enum() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_union() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseLPAREN() and blk_5: {
                    const pos_5 = p.i;
                    if (try p.parseKEYWORD_enum() and (blk_8: {
                        const pos_8 = p.i;
                        if (try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_8 true;
                        p.i = pos_8;
                        break :blk_8 false;
                    } or true)) break :blk_5 true;
                    p.i = pos_5;
                    if (try p.parseExpr()) break :blk_5 true;
                    p.i = pos_5;
                    break :blk_5 false;
                } and try p.parseRPAREN()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseByteAlign(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defByteAlign);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_align() and try p.parseLPAREN() and try p.parseExpr() and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBitAlign(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBitAlign);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_align() and try p.parseLPAREN() and try p.parseExpr() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseCOLON() and try p.parseExpr() and try p.parseCOLON() and try p.parseExpr()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true) and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseIdentifierList(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defIdentifierList);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((blk_3: {
                const pos_3 = p.i;
                if ((try p.parsedoc_comment() or true) and try p.parseIDENTIFIER() and (blk_6: {
                    const pos_6 = p.i;
                    if (try p.parseCOMMA() and try p.parseIdentifierList()) break :blk_6 true;
                    p.i = pos_6;
                    break :blk_6 false;
                } or true)) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSwitchProngList(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSwitchProngList);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((blk_3: {
                const pos_3 = p.i;
                if (try p.parseSwitchProng() and (blk_6: {
                    const pos_6 = p.i;
                    if (try p.parseCOMMA() and try p.parseSwitchProngList()) break :blk_6 true;
                    p.i = pos_6;
                    break :blk_6 false;
                } or true)) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAsmOutputList(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAsmOutputList);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((blk_3: {
                const pos_3 = p.i;
                if (try p.parseAsmOutputItem() and (blk_6: {
                    const pos_6 = p.i;
                    if (try p.parseCOMMA() and try p.parseAsmOutputList()) break :blk_6 true;
                    p.i = pos_6;
                    break :blk_6 false;
                } or true)) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAsmInputList(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAsmInputList);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((blk_3: {
                const pos_3 = p.i;
                if (try p.parseAsmInputItem() and (blk_6: {
                    const pos_6 = p.i;
                    if (try p.parseCOMMA() and try p.parseAsmInputList()) break :blk_6 true;
                    p.i = pos_6;
                    break :blk_6 false;
                } or true)) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseParamDeclList(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defParamDeclList);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseLPAREN() and try p.parseParamDeclListRest()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseParamDeclListRest(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defParamDeclListRest);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseDOT3() and (try p.parseCOMMA() or true) and try p.parseRPAREN()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseParamDecl() and blk_2: {
                const pos_2 = p.i;
                if (try p.parseCOMMA() and try p.parseParamDeclListRest()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseRPAREN()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseExprList(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defExprList);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseExpr() and (blk_3: {
                const pos_3 = p.i;
                if (try p.parseCOMMA() and try p.parseExprList()) break :blk_3 true;
                p.i = pos_3;
                break :blk_3 false;
            } or true)) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parseExprPrefix();
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseExprPrefix(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defExprPrefix);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseASTERISK()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsebyte_order_mark(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defbyte_order_mark);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\xef\xbb\xbf")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsesof(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defsof);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i == 0) and (try p.parsebyte_order_mark() or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseeof(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defeof);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = blk_2: {
                    if (p.i < p.source.len) {
                        p.i += 1;
                        break :blk_2 true;
                    }
                    break :blk_2 false;
                };
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseox80_oxBF(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defox80_oxBF);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\x80'...'\xbf',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxF4(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxF4);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\xf4")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseox80_ox8F(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defox80_ox8F);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\x80'...'\x8f',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxF1_oxF3(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxF1_oxF3);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\xf1'...'\xf3',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxF0(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxF0);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\xf0")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseox90_0xBF(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defox90_0xBF);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\x90'...'\xbf',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxEE_oxEF(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxEE_oxEF);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\xee'...'\xef',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxED(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxED);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\xed")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseox80_ox9F(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defox80_ox9F);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\x80'...'\x9f',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxE1_oxEC(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxE1_oxEC);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\xe1'...'\xec',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxE0(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxE0);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\xe0")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxA0_oxBF(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxA0_oxBF);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\xa0'...'\xbf',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseoxC2_oxDF(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defoxC2_oxDF);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '\xc2'...'\xdf',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsemultibyte_utf8(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defmultibyte_utf8);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseoxF4() and try p.parseox80_ox8F() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseoxF1_oxF3() and try p.parseox80_oxBF() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseoxF0() and try p.parseox90_0xBF() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseoxEE_oxEF() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseoxED() and try p.parseox80_ox9F() and try p.parseox80_oxBF()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseoxE1_oxEC() and try p.parseox80_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseoxE0() and try p.parseoxA0_oxBF() and try p.parseox80_oxBF()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseoxC2_oxDF() and try p.parseox80_oxBF()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsenon_control_ascii(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defnon_control_ascii);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                ' '...'~',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsenon_control_utf8(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defnon_control_utf8);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                ' '...'~',
                '\x80'...'\xff',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsechar_char(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defchar_char);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\\\\")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\\'")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '\''...'\'',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parsenon_control_utf8()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsestring_char(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defstring_char);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\\\\")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\\\"")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '"'...'"',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            } and try p.parsenon_control_utf8()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsecontainer_doc_comment(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defcontainer_doc_comment);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                var match_1 = false;
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseskip() and blk_4: {
                        if (std.mem.startsWith(u8, p.source[p.i..], "//!")) {
                            p.i += 3;
                            break :blk_4 true;
                        }
                        break :blk_4 false;
                    } and blk_4: {
                        var i_4: usize = 0;
                        while (try p.parsenon_control_utf8()) {
                            if (i_4 > max_depth) return error.MaxDepth;
                            i_4 += 1;
                        }
                        break :blk_4 true;
                    } and try p.parsenewline()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    match_1 = true;
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsedoc_comment(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defdoc_comment);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_2: {
                const pos_2 = p.i;
                if (try p.parsesof()) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseskip_require_newline()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            } and blk_1: {
                var match_1 = false;
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseskip() and blk_4: {
                        if (std.mem.startsWith(u8, p.source[p.i..], "///")) {
                            p.i += 3;
                            break :blk_4 true;
                        }
                        break :blk_4 false;
                    } and blk_4: {
                        var i_4: usize = 0;
                        while (try p.parsenon_control_utf8()) {
                            if (i_4 > max_depth) return error.MaxDepth;
                            i_4 += 1;
                        }
                        break :blk_4 true;
                    } and try p.parsenewline()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    match_1 = true;
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseline_comment(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defline_comment);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "//")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '!'...'!',
                    '/'...'/',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            } and blk_1: {
                var i_1: usize = 0;
                while (try p.parsenon_control_utf8()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and try p.parsenewline()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "////")) {
                    p.i += 4;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                var i_1: usize = 0;
                while (try p.parsenon_control_utf8()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and try p.parsenewline()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseline_string(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defline_string);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "\\\\")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                var i_1: usize = 0;
                while (try p.parsenon_control_utf8()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and try p.parsenewline()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsenewline(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defnewline);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = blk_3: {
                    const pos_3 = p.i;
                    if (blk_4: {
                        if (std.mem.startsWith(u8, p.source[p.i..], "\n")) {
                            p.i += 1;
                            break :blk_4 true;
                        }
                        break :blk_4 false;
                    }) break :blk_3 true;
                    p.i = pos_3;
                    if (blk_4: {
                        if (std.mem.startsWith(u8, p.source[p.i..], "\r\n")) {
                            p.i += 2;
                            break :blk_4 true;
                        }
                        break :blk_4 false;
                    }) break :blk_3 true;
                    p.i = pos_3;
                    if (try p.parseeof()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                };
                p.i = pos_1;
                break :blk_1 match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseskip(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defskip);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((try p.parsesof() or true) and blk_1: {
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if ((p.i < p.source.len and switch (p.source[p.i]) {
                        ' '...' ',
                        '\n'...'\n',
                        '\t'...'\t',
                        '\r'...'\r',
                        => blk_4: {
                            p.i += 1;
                            break :blk_4 true;
                        },
                        else => false,
                    })) break :blk_3 true;
                    p.i = pos_3;
                    if (try p.parseline_comment()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseskip_require_newline(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defskip_require_newline);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                var i_1: usize = 0;
                while ((p.i < p.source.len and switch (p.source[p.i]) {
                    ' '...' ',
                    '\t'...'\t',
                    '\r'...'\r',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                })) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_2: {
                const pos_2 = p.i;
                if ((p.i < p.source.len and switch (p.source[p.i]) {
                    '\n'...'\n',
                    => blk_3: {
                        p.i += 1;
                        break :blk_3 true;
                    },
                    else => false,
                })) break :blk_2 true;
                p.i = pos_2;
                if (try p.parseline_comment()) break :blk_2 true;
                p.i = pos_2;
                break :blk_2 false;
            } and try p.parseskip()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsepre_op_white(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defpre_op_white);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                var match_1 = false;
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if ((p.i < p.source.len and switch (p.source[p.i]) {
                        ' '...' ',
                        '\n'...'\n',
                        '\t'...'\t',
                        '\r'...'\r',
                        => blk_4: {
                            p.i += 1;
                            break :blk_4 true;
                        },
                        else => false,
                    })) break :blk_3 true;
                    p.i = pos_3;
                    if (try p.parseline_comment()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    match_1 = true;
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsepost_op_white(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defpost_op_white);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                ' '...' ',
                '\n'...'\n',
                '\t'...'\t',
                '\r'...'\r',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            }) and try p.parseskip()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCHAR_LITERAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCHAR_LITERAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
                '\''...'\'',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            }) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsechar_char()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (p.i < p.source.len and switch (p.source[p.i]) {
                '\''...'\'',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsedigit(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defdigit);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '_'...'_',
                '0'...'9',
                'A'...'D',
                'F'...'O',
                'Q'...'Z',
                'a'...'d',
                'f'...'o',
                'q'...'z',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsedigit_int(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defdigit_int);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsedigit()) break :blk_0 true;
            p.i = pos_0;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                'e'...'e',
                'E'...'E',
                'p'...'p',
                'P'...'P',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsedigit_float(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defdigit_float);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parsedigit()) break :blk_0 true;
            p.i = pos_0;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                'e'...'e',
                'E'...'E',
                'p'...'p',
                'P'...'P',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            }) and ((p.i < p.source.len and switch (p.source[p.i]) {
                '-'...'-',
                '+'...'+',
                => blk_2: {
                    p.i += 1;
                    break :blk_2 true;
                },
                else => false,
            }) or true)) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseNUMBERLITERAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defNUMBERLITERAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
                '0'...'9',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            }) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsedigit_int()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                var match_1 = false;
                var i_1: usize = 0;
                while (try p.parsedigit_float()) {
                    match_1 = true;
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseskip() and (p.i < p.source.len and switch (p.source[p.i]) {
                '0'...'9',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            }) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsedigit_float()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsestring(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defstring);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if ((p.i < p.source.len and switch (p.source[p.i]) {
                '"'...'"',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            }) and blk_1: {
                var i_1: usize = 0;
                while (try p.parsestring_char()) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            } and (p.i < p.source.len and switch (p.source[p.i]) {
                '"'...'"',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            })) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSTRINGLITERALSINGLE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSTRINGLITERALSINGLE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and try p.parsestring()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSTRINGLITERAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSTRINGLITERAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and try p.parsestring()) break :blk_0 true;
            p.i = pos_0;
            if (blk_1: {
                var match_1 = false;
                var i_1: usize = 0;
                while (blk_3: {
                    const pos_3 = p.i;
                    if (try p.parseskip() and try p.parseline_string()) break :blk_3 true;
                    p.i = pos_3;
                    break :blk_3 false;
                }) {
                    match_1 = true;
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseIDENTIFIER(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defIDENTIFIER);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                const pos_1 = p.i;
                const match_1 = try p.parsekeyword();
                p.i = pos_1;
                break :blk_1 !match_1;
            } and (p.i < p.source.len and switch (p.source[p.i]) {
                'A'...'Z',
                'a'...'z',
                '_'...'_',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            }) and blk_1: {
                var i_1: usize = 0;
                while ((p.i < p.source.len and switch (p.source[p.i]) {
                    'A'...'Z',
                    'a'...'z',
                    '0'...'9',
                    '_'...'_',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                })) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parsestring()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseBUILTINIDENTIFIER(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defBUILTINIDENTIFIER);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and (p.i < p.source.len and switch (p.source[p.i]) {
                'A'...'Z',
                'a'...'z',
                '_'...'_',
                => blk_1: {
                    p.i += 1;
                    break :blk_1 true;
                },
                else => false,
            }) and blk_1: {
                var i_1: usize = 0;
                while ((p.i < p.source.len and switch (p.source[p.i]) {
                    'A'...'Z',
                    'a'...'z',
                    '0'...'9',
                    '_'...'_',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                })) {
                    if (i_1 > max_depth) return error.MaxDepth;
                    i_1 += 1;
                }
                break :blk_1 true;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAMPERSAND(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAMPERSAND);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "&")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseAMPERSANDEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defAMPERSANDEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "&=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseASTERISK(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defASTERISK);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "*")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '%'...'%',
                    '='...'=',
                    '|'...'|',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseASTERISKEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defASTERISKEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "*=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseASTERISKPERCENT(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defASTERISKPERCENT);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "*%")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseASTERISKPERCENTEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defASTERISKPERCENTEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "*%=")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseASTERISKPIPE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defASTERISKPIPE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "*|")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseASTERISKPIPEEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defASTERISKPIPEEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "*|=")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCARET(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCARET);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "^")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCARETEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCARETEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "^=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCOLON(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCOLON);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ":")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseCOMMA(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defCOMMA);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ",")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseDOT(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defDOT);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '*'...'*',
                    '.'...'.',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseDOT2(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defDOT2);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "..")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '.'...'.',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseDOT3(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defDOT3);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "...")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseDOTASTERISK(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defDOTASTERISK);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ".*")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "=")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '>'...'>',
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseEQUALEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defEQUALEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "==")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseEQUALRARROW(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defEQUALRARROW);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "=>")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseEXCLAMATIONMARK(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defEXCLAMATIONMARK);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "!")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseEXCLAMATIONMARKEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defEXCLAMATIONMARKEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "!=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLARROW(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLARROW);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "<")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '<'...'<',
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLARROW2(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLARROW2);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "<<")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    '|'...'|',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLARROW2EQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLARROW2EQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "<<=")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLARROW2PIPE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLARROW2PIPE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "<<|")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLARROW2PIPEEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLARROW2PIPEEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "<<|=")) {
                    p.i += 4;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLARROWEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLARROWEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "<=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLBRACE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLBRACE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "{")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLBRACKET(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLBRACKET);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "[")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLPAREN(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLPAREN);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "(")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMINUS(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMINUS);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "-")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '%'...'%',
                    '='...'=',
                    '>'...'>',
                    '|'...'|',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMINUSEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMINUSEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "-=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMINUSPERCENT(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMINUSPERCENT);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "-%")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMINUSPERCENTEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMINUSPERCENTEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "-%=")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMINUSPIPE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMINUSPIPE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "-|")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMINUSPIPEEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMINUSPIPEEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "-|=")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseMINUSRARROW(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defMINUSRARROW);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "->")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePERCENT(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPERCENT);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "%")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePERCENTEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPERCENTEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "%=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePIPE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPIPE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "|")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '|'...'|',
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePIPE2(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPIPE2);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "||")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePIPEEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPIPEEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "|=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePLUS(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPLUS);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "+")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '%'...'%',
                    '+'...'+',
                    '='...'=',
                    '|'...'|',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePLUS2(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPLUS2);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "++")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePLUSEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPLUSEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "+=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePLUSPERCENT(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPLUSPERCENT);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "+%")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePLUSPERCENTEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPLUSPERCENTEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "+%=")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePLUSPIPE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPLUSPIPE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "+|")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsePLUSPIPEEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defPLUSPIPEEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "+|=")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseLETTERC(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defLETTERC);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "c")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseQUESTIONMARK(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defQUESTIONMARK);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "?")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseRARROW(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defRARROW);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ">")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '>'...'>',
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseRARROW2(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defRARROW2);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ">>")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseRARROW2EQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defRARROW2EQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ">>=")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseRARROWEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defRARROWEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ">=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseRBRACE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defRBRACE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "}")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseRBRACKET(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defRBRACKET);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "]")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseRPAREN(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defRPAREN);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ")")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSEMICOLON(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSEMICOLON);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], ";")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSLASH(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSLASH);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "/")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    '='...'=',
                    '/'...'/',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseSLASHEQUAL(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defSLASHEQUAL);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "/=")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseTILDE(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defTILDE);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "~")) {
                    p.i += 1;
                    break :blk_1 true;
                }
                break :blk_1 false;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseend_of_word(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defend_of_word);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (blk_1: {
                const pos_1 = p.i;
                const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
                    'a'...'z',
                    'A'...'Z',
                    '0'...'9',
                    '_'...'_',
                    => blk_2: {
                        p.i += 1;
                        break :blk_2 true;
                    },
                    else => false,
                });
                p.i = pos_1;
                break :blk_1 !match_1;
            }) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_addrspace(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_addrspace);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "addrspace")) {
                    p.i += 9;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_align(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_align);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "align")) {
                    p.i += 5;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_allowzero(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_allowzero);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "allowzero")) {
                    p.i += 9;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_and(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_and);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "and")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_anyframe(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_anyframe);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "anyframe")) {
                    p.i += 8;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_anytype(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_anytype);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "anytype")) {
                    p.i += 7;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_asm(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_asm);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "asm")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_break(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_break);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "break")) {
                    p.i += 5;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_callconv(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_callconv);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "callconv")) {
                    p.i += 8;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_catch(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_catch);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "catch")) {
                    p.i += 5;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_comptime(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_comptime);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "comptime")) {
                    p.i += 8;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_const(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_const);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "const")) {
                    p.i += 5;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_continue(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_continue);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "continue")) {
                    p.i += 8;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_defer(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_defer);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "defer")) {
                    p.i += 5;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_else(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_else);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "else")) {
                    p.i += 4;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_enum(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_enum);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "enum")) {
                    p.i += 4;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_errdefer(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_errdefer);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "errdefer")) {
                    p.i += 8;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_error(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_error);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "error")) {
                    p.i += 5;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_export(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_export);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "export")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_extern(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_extern);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "extern")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_fn(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_fn);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "fn")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_for(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_for);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "for")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_if(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_if);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "if")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_inline(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_inline);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "inline")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_noalias(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_noalias);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "noalias")) {
                    p.i += 7;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_nosuspend(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_nosuspend);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "nosuspend")) {
                    p.i += 9;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_noinline(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_noinline);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "noinline")) {
                    p.i += 8;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_opaque(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_opaque);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "opaque")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_or(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_or);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "or")) {
                    p.i += 2;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_orelse(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_orelse);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "orelse")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_packed(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_packed);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "packed")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_pub(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_pub);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "pub")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_resume(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_resume);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "resume")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_return(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_return);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "return")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_linksection(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_linksection);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "linksection")) {
                    p.i += 11;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_struct(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_struct);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "struct")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_suspend(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_suspend);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "suspend")) {
                    p.i += 7;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_switch(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_switch);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "switch")) {
                    p.i += 6;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_test(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_test);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "test")) {
                    p.i += 4;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_threadlocal(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_threadlocal);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "threadlocal")) {
                    p.i += 11;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_try(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_try);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "try")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_union(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_union);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "union")) {
                    p.i += 5;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_unreachable(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_unreachable);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "unreachable")) {
                    p.i += 11;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_var(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_var);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "var")) {
                    p.i += 3;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_volatile(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_volatile);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "volatile")) {
                    p.i += 8;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parseKEYWORD_while(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defKEYWORD_while);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseskip() and blk_1: {
                if (std.mem.startsWith(u8, p.source[p.i..], "while")) {
                    p.i += 5;
                    break :blk_1 true;
                }
                break :blk_1 false;
            } and try p.parseend_of_word()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
    pub fn parsekeyword(p: *Parser) Error!bool {
        const def_index = @backingInt(Def.defkeyword);
        if (p.depths[def_index] > max_depth) return error.MaxDepth;
        p.depths[def_index] += 1;
        defer p.depths[def_index] -= 1;
        return blk_0: {
            const pos_0 = p.i;
            if (try p.parseKEYWORD_addrspace()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_align()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_allowzero()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_and()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_anyframe()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_anytype()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_asm()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_break()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_callconv()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_catch()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_comptime()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_const()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_continue()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_defer()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_else()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_enum()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_errdefer()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_error()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_export()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_extern()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_fn()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_for()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_if()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_inline()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_noalias()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_nosuspend()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_noinline()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_opaque()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_or()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_orelse()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_packed()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_pub()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_resume()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_return()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_linksection()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_struct()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_suspend()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_switch()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_test()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_threadlocal()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_try()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_union()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_unreachable()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_var()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_volatile()) break :blk_0 true;
            p.i = pos_0;
            if (try p.parseKEYWORD_while()) break :blk_0 true;
            p.i = pos_0;
            break :blk_0 false;
        };
    }
};