All files

src/compiler/parser.panack

Green: covered; red: known zero; amber: unavailable. Blank lines are outside the executable-start-line denominator.

    1 import "lexer.panack"
    2 
    3 enum Expr {
    4   LocatedExpr(SourceSpan, Expr),
    5   NatExpr(Nat),
    6   DecimalExpr(Str),
    7   StringExpr(Str),
    8   BoolExpr(Bool),
    9   NameExpr(Str),
   10   FunctionExpr(Str),
   11   ArrayExpr([Expr]),
   12   UnaryExpr(Str, Expr),
   13   BinaryExpr(Str, Expr, Expr),
   14   // Callee, value arguments, and optional complete explicit type arguments.
   15   CallExpr(Str, [Expr], [Str]),
   16   // Raw dot calls retain the receiver and spelling until namespace resolution.
   17   DotCallExpr(Expr, Str, [Expr], [Str]),
   18   FieldExpr(Expr, Str),
   19   IndexExpr(Expr, Expr),
   20   IfExpr(Expr, Block, Block, Bool),
   21   BlockExpr(Block),
   22   MatchExpr(Expr, [MatchArm])
   23 }
   24 
   25 pure unlocated_expression(expression: Expr): Expr {
   26   mut result: Expr = expression
   27   match expression {
   28     LocatedExpr(position, value) => { result = unlocated_expression(value); },
   29     NatExpr(value) => {}, DecimalExpr(text) => {}, StringExpr(text) => {}, BoolExpr(value) => {},
   30     NameExpr(name) => {}, FunctionExpr(name) => {}, ArrayExpr(items) => {},
   31     UnaryExpr(operator, operand) => {}, BinaryExpr(operator, left, right) => {},
   32     CallExpr(name, arguments, type_arguments) => {}, DotCallExpr(target, name, arguments, types) => {}, FieldExpr(target, field) => {}, IndexExpr(target, index) => {},
   33     IfExpr(condition, yes, no, has_else) => {}, BlockExpr(block) => {}, MatchExpr(subject, arms) => {}
   34   }
   35   result
   36 }
   37 
   38 record MatchPattern {
   39   variant: Str,
   40   bindings: [Str]
   41 }
   42 
   43 record MatchArm {
   44   pattern: MatchPattern,
   45   body: Expr
   46 }
   47 
   48 enum TopLevel {
   49   ImportDeclaration(Str),
   50   TypeDeclaration(Str, Str, Expr),
   51   RecordDeclaration(Str, [Str], [RecordField]),
   52   EnumDeclaration(Str, [Str], [EnumVariant]),
   53   // Name, value parameters, return type, purity, async effect, body, type parameters.
   54   FunctionDeclaration(Str, [FunctionParameter], Str, Bool, Bool, Block, [Str])
   55 }
   56 
   57 record RecordField {
   58   name: Str,
   59   type_name: Str
   60 }
   61 
   62 record EnumVariant {
   63   name: Str,
   64   payload: [Str]
   65 }
   66 
   67 record FunctionParameter {
   68   name: Str,
   69   type_name: Str
   70 }
   71 
   72 record IndexedVariant {
   73   enum_name: Str,
   74   parameters: [Str],
   75   payload: [Str]
   76 }
   77 
   78 record Program {
   79   declarations: [TopLevel],
   80   type_indices: Map[Str,Nat],
   81   record_indices: Map[Str,Nat],
   82   enum_indices: Map[Str,Nat],
   83   function_indices: Map[Str,Nat],
   84   variants: Map[Str,IndexedVariant]
   85 }
   86 
   87 // Preserve source order for diagnostics/emission; indexes only accelerate lookup.
   88 // Separate namespaces and last-write wins reproduce the previous lookup scans,
   89 // including malformed programs inspected directly before resolver rejection.
   90 pure indexed_program(declarations: [TopLevel]): Program {
   91   mut types: Map[Str,Nat] = map()
   92   mut records: Map[Str,Nat] = map()
   93   mut enums: Map[Str,Nat] = map()
   94   mut functions: Map[Str,Nat] = map()
   95   mut variants: Map[Str,IndexedVariant] = map()
   96   mut index: Nat = 0
   97   for declaration in declarations {
   98     match declaration {
   99       ImportDeclaration(path) => {},
  100       TypeDeclaration(name, base, guard) => { types = map_put(types, name, index); },
  101       RecordDeclaration(name, parameters, fields) => { records = map_put(records, name, index); },
  102       EnumDeclaration(name, parameters, values) => {
  103         enums = map_put(enums, name, index)
  104         for value in values {
  105           variants = map_put(variants, value.name, IndexedVariant(name, parameters, value.payload))
  106         }
  107       },
  108       FunctionDeclaration(name, parameters, return_type, is_pure, is_async, body, type_parameters) => {
  109         functions = map_put(functions, name, index)
  110       }
  111     }
  112     index = index + 1
  113   }
  114   Program(declarations, types, records, enums, functions, variants)
  115 }
  116 
  117 enum Statement {
  118   // Empty type text means an inferred explicit declaration (mut name = value).
  119   BindingStatement(Str, Str, Bool, Expr),
  120   // Plain = is resolved as declaration or assignment using the lexical scope.
  121   AssignmentStatement(Str, Expr),
  122   ExpressionStatement(Expr),
  123   WhileStatement(Expr, Block),
  124   ForStatement(Str, Expr, Block)
  125 }
  126 
  127 enum BlockValue {
  128   NoBlockValue,
  129   TailBlockValue(Expr)
  130 }
  131 
  132 record Block {
  133   statements: [Statement],
  134   value: BlockValue
  135 }
  136 
  137 record ParsedExpr {
  138   value: Expr,
  139   next: Nat
  140 }
  141 
  142 record ParsedExprList {
  143   values: [Expr],
  144   next: Nat
  145 }
  146 
  147 record ParsedNameList {
  148   values: [Str],
  149   next: Nat
  150 }
  151 
  152 record ParsedMatchArmList {
  153   values: [MatchArm],
  154   next: Nat
  155 }
  156 
  157 record ParsedTypeRef {
  158   text: Str,
  159   next: Nat
  160 }
  161 
  162 record ParsedImportPath {
  163   text: Str,
  164   next: Nat
  165 }
  166 
  167 record ParsedTypeRefList {
  168   values: [Str],
  169   next: Nat
  170 }
  171 
  172 record ParsedBlock {
  173   value: Block,
  174   next: Nat
  175 }
  176 
  177 record ParsedTopLevel {
  178   value: TopLevel,
  179   next: Nat
  180 }
  181 
  182 pure token_end_position(tokens: [Token], next: Nat): SourcePos {
  183   if next > 0 {
  184     last: Nat = next - 1
  185     if last < len(tokens) {
  186       token: Token = tokens[last]
  187       SourcePos(token.position.file, token.end, token.end_line, token.end_column)
  188     } else { SourcePos("", 0, 0, 0) }
  189   } else { SourcePos("", 0, 0, 0) }
  190 }
  191 
  192 pure located_expression(tokens: [Token], index: Nat, next: Nat, value: Expr): Expr {
  193   LocatedExpr(SourceSpan(token_position(tokens, index), token_end_position(tokens, next)), unlocated_expression(value))
  194 }
  195 
  196 pure expression_span(expression: Expr): Option[SourceSpan] {
  197   match expression {
  198     LocatedExpr(span, value) => Some(span),
  199     NatExpr(value) => None(), DecimalExpr(text) => None(), StringExpr(text) => None(), BoolExpr(value) => None(),
  200     NameExpr(name) => None(), FunctionExpr(name) => None(), ArrayExpr(items) => None(),
  201     UnaryExpr(operator, operand) => None(), BinaryExpr(operator, left, right) => None(),
  202     CallExpr(name, arguments, type_arguments) => None(), DotCallExpr(target, name, arguments, types) => None(), FieldExpr(target, field) => None(), IndexExpr(target, index) => None(),
  203     IfExpr(condition, yes, no, has_else) => None(), BlockExpr(block) => None(), MatchExpr(subject, arms) => None()
  204   }
  205 }
  206 
  207 // Postfix and binary parsers retain the left expression's original beginning.
  208 // An unlocated synthetic input stays unlocated rather than acquiring a guess.
  209 pure extended_expression(tokens: [Token], left: Expr, next: Nat, value: Expr): Expr {
  210   match expression_span(left) {
  211     Some(span) => LocatedExpr(SourceSpan(span.start, token_end_position(tokens, next)), value),
  212     None() => value
  213   }
  214 }
  215 
  216 record ParsedFunctionParameterList {
  217   values: [FunctionParameter],
  218   next: Nat
  219 }
  220 
  221 pure parse_error(message: Str, position: SourcePos): Diagnostic {
  222   Diagnostic(message, position)
  223 }
  224 
  225 pure string_token_value(text: Str): Str {
  226   mut cursor: Nat = 1
  227   mut closing: Nat = len(text)
  228   mut escaped: Bool = false
  229   mut found: Bool = false
  230   while cursor < len(text) && !found {
  231     if escaped {
  232       escaped = false
  233     } else {
  234       if text[cursor] == "\\" {
  235         escaped = true
  236       } else {
  237         if text[cursor] == "\"" {
  238           closing = cursor
  239           found = true
  240         } else {
  241         }
  242       }
  243     }
  244     cursor = cursor + 1
  245   }
  246   slice(text, 1, closing)
  247 }
  248 
  249 pure token_position(tokens: [Token], index: Nat): SourcePos {
  250   if index < len(tokens) {
  251     tokens[index].position
  252   } else {
  253     mut position: SourcePos = SourcePos("", 0, 1, 1)
  254     for token in tokens {
  255       position = SourcePos(token.position.file, token.end, token.end_line, token.end_column)
  256     }
  257     position
  258   }
  259 }
  260 
  261 pure parse_logical_import_path_tail(tokens: [Token], text: Str, index: Nat, has_separator: Bool): Result[ParsedImportPath,Diagnostic] {
  262   if index < len(tokens) && tokens[index].text == "/" {
  263     segment_index: Nat = index + 1
  264     if segment_index >= len(tokens) || tokens[segment_index].kind != Identifier() {
  265       Error(parse_error("expected logical import path segment", token_position(tokens, segment_index)))
  266     } else {
  267       segment: Str = tokens[segment_index].text
  268       parse_logical_import_path_tail(tokens, "${text}/${segment}", segment_index + 1, true)
  269     }
  270   } else {
  271     if index < len(tokens) && tokens[index].text == "." {
  272       suffix_index: Nat = index + 1
  273       if suffix_index >= len(tokens) || tokens[suffix_index].kind != Identifier() || tokens[suffix_index].text != "panack" {
  274         Error(parse_error("logical import extension must be .panack", token_position(tokens, suffix_index)))
  275       } else {
  276         if has_separator {
  277           Ok(ParsedImportPath(text, suffix_index + 1))
  278         } else {
  279           Error(parse_error("expected '/' in logical import path", token_position(tokens, index)))
  280         }
  281       }
  282     } else {
  283       if has_separator {
  284         Ok(ParsedImportPath(text, index))
  285       } else {
  286         Error(parse_error("expected '/' in logical import path", token_position(tokens, index)))
  287       }
  288     }
  289   }
  290 }
  291 
  292 pure parse_import_path(tokens: [Token], index: Nat): Result[ParsedImportPath,Diagnostic] {
  293   if index >= len(tokens) {
  294     Error(parse_error("expected import path", token_position(tokens, index)))
  295   } else {
  296     if tokens[index].kind == StringLiteral() {
  297       Ok(ParsedImportPath(string_token_value(tokens[index].text), index + 1))
  298     } else {
  299       if tokens[index].kind == Identifier() {
  300         parse_logical_import_path_tail(tokens, tokens[index].text, index + 1, false)
  301       } else {
  302         Error(parse_error("expected import path", token_position(tokens, index)))
  303       }
  304     }
  305   }
  306 }
  307 
  308 pure render_type_ref_list(types: [Str]): Str {
  309   mut output: Str = ""
  310   mut first: Bool = true
  311   for type_name in types {
  312     if first {
  313       first = false
  314     } else {
  315       output = output + ","
  316     }
  317     output = output + type_name
  318   }
  319   output
  320 }
  321 
  322 pure parse_type_ref_list_tail(tokens: [Token], values: [Str], index: Nat): Result[ParsedTypeRefList,Diagnostic] {
  323   if index >= len(tokens) {
  324     Error(parse_error("expected closing type bracket", token_position(tokens, index)))
  325   } else {
  326     if tokens[index].text == "]" {
  327       Ok(ParsedTypeRefList(values, index + 1))
  328     } else {
  329       if tokens[index].text == "," {
  330         match parse_type_ref(tokens, index + 1) {
  331           Ok(parsed) => parse_type_ref_list_tail(tokens, append(values, parsed.text), parsed.next),
  332           Error(error) => Error(error)
  333         }
  334       } else {
  335         Error(parse_error("expected comma or closing type bracket", tokens[index].position))
  336       }
  337     }
  338   }
  339 }
  340 
  341 pure parse_type_ref_list(tokens: [Token], index: Nat): Result[ParsedTypeRefList,Diagnostic] {
  342   match parse_type_ref(tokens, index) {
  343     Ok(parsed) => {
  344       values: [Str] = [parsed.text]
  345       parse_type_ref_list_tail(tokens, values, parsed.next)
  346     },
  347     Error(error) => Error(error)
  348   }
  349 }
  350 
  351 pure parse_reference_path(tokens: [Token], index: Nat): Result[ParsedTypeRef,Diagnostic] {
  352   if index >= len(tokens) || tokens[index].kind != Identifier() {
  353     Error(parse_error("expected reference name", token_position(tokens, index)))
  354   } else {
  355     mut name: Str = tokens[index].text
  356     mut cursor: Nat = index + 1
  357     mut invalid: Bool = false
  358     while cursor < len(tokens) && tokens[cursor].text == "." && !invalid {
  359       if cursor + 1 < len(tokens) && tokens[cursor + 1].kind == Identifier() {
  360         name = name + "." + tokens[cursor + 1].text
  361         cursor = cursor + 2
  362       } else { invalid = true }
  363     }
  364     if invalid { Error(parse_error("expected name after '.'", token_position(tokens, cursor + 1))) }
  365     else { Ok(ParsedTypeRef(name, cursor)) }
  366   }
  367 }
  368 
  369 pure parse_type_ref(tokens: [Token], index: Nat): Result[ParsedTypeRef,Diagnostic] {
  370   if index >= len(tokens) {
  371     Error(parse_error("expected type", token_position(tokens, index)))
  372   } else {
  373     if tokens[index].text == "[" {
  374       match parse_type_ref(tokens, index + 1) {
  375         Ok(inner) => {
  376           if inner.next < len(tokens) && tokens[inner.next].text == "]" {
  377             text: Str = inner.text
  378             Ok(ParsedTypeRef("[${text}]", inner.next + 1))
  379           } else {
  380             Error(parse_error("expected closing type bracket", token_position(tokens, inner.next)))
  381           }
  382         },
  383         Error(error) => Error(error)
  384       }
  385     } else {
  386       if tokens[index].kind == Identifier() {
  387         match parse_reference_path(tokens, index) {
  388         Error(error) => Error(error),
  389         Ok(path) => {
  390         name: Str = path.text
  391         if path.next < len(tokens) && tokens[path.next].text == "[" {
  392           match parse_type_ref_list(tokens, path.next + 1) {
  393             Ok(arguments) => {
  394               argument_text: Str = render_type_ref_list(arguments.values)
  395               Ok(ParsedTypeRef("${name}[${argument_text}]", arguments.next))
  396             },
  397             Error(error) => Error(error)
  398           }
  399         } else {
  400           Ok(ParsedTypeRef(name, path.next))
  401         }
  402         }
  403         }
  404       } else {
  405         Error(parse_error("expected type", tokens[index].position))
  406       }
  407     }
  408   }
  409 }
  410 
  411 pure parse_type_complete(tokens: [Token]): Result[Str,Diagnostic] {
  412   match parse_type_ref(tokens, 0) {
  413     Ok(parsed) => {
  414       if parsed.next == len(tokens) {
  415         Ok(parsed.text)
  416       } else {
  417         Error(parse_error("unexpected token after type", tokens[parsed.next].position))
  418       }
  419     },
  420     Error(error) => Error(error)
  421   }
  422 }
  423 
  424 pure parse_generic_parameter_tail(tokens: [Token], parameters: [Str], index: Nat): Result[ParsedNameList,Diagnostic] {
  425   if index >= len(tokens) {
  426     Error(parse_error("expected closing type parameter bracket", token_position(tokens, index)))
  427   } else {
  428     if tokens[index].text == "]" {
  429       Ok(ParsedNameList(parameters, index + 1))
  430     } else {
  431       if tokens[index].text == "," {
  432         parameter_index: Nat = index + 1
  433         if parameter_index >= len(tokens) || tokens[parameter_index].kind != Identifier() {
  434           Error(parse_error("expected type parameter", token_position(tokens, parameter_index)))
  435         } else {
  436           parse_generic_parameter_tail(tokens, append(parameters, tokens[parameter_index].text), parameter_index + 1)
  437         }
  438       } else {
  439         Error(parse_error("expected comma or closing type parameter bracket", tokens[index].position))
  440       }
  441     }
  442   }
  443 }
  444 
  445 pure parse_generic_parameters(tokens: [Token], index: Nat): Result[ParsedNameList,Diagnostic] {
  446   if index >= len(tokens) || tokens[index].text != "[" {
  447     parameters: [Str] = []
  448     Ok(ParsedNameList(parameters, index))
  449   } else {
  450     first_index: Nat = index + 1
  451     if first_index >= len(tokens) || tokens[first_index].kind != Identifier() {
  452       Error(parse_error("expected type parameter", token_position(tokens, first_index)))
  453     } else {
  454       parameters: [Str] = [tokens[first_index].text]
  455       parse_generic_parameter_tail(tokens, parameters, first_index + 1)
  456     }
  457   }
  458 }
  459 
  460 pure parse_variant_payload_tail(tokens: [Token], payload: [Str], index: Nat): Result[ParsedTypeRefList,Diagnostic] {
  461   if index >= len(tokens) {
  462     Error(parse_error("expected closing variant parenthesis", token_position(tokens, index)))
  463   } else {
  464     if tokens[index].text == ")" {
  465       Ok(ParsedTypeRefList(payload, index + 1))
  466     } else {
  467       if tokens[index].text == "," {
  468         match parse_type_ref(tokens, index + 1) {
  469           Ok(parsed) => parse_variant_payload_tail(tokens, append(payload, parsed.text), parsed.next),
  470           Error(error) => Error(error)
  471         }
  472       } else {
  473         Error(parse_error("expected comma or closing variant parenthesis", tokens[index].position))
  474       }
  475     }
  476   }
  477 }
  478 
  479 pure parse_variant_payload(tokens: [Token], index: Nat): Result[ParsedTypeRefList,Diagnostic] {
  480   if index < len(tokens) && tokens[index].text == ")" {
  481     payload: [Str] = []
  482     Ok(ParsedTypeRefList(payload, index + 1))
  483   } else {
  484     match parse_type_ref(tokens, index) {
  485       Ok(parsed) => {
  486         payload: [Str] = [parsed.text]
  487         parse_variant_payload_tail(tokens, payload, parsed.next)
  488       },
  489       Error(error) => Error(error)
  490     }
  491   }
  492 }
  493 
  494 pure parse_expression_list_tail(tokens: [Token], values: [Expr], index: Nat, closing: Str): Result[ParsedExprList,Diagnostic] {
  495   if index >= len(tokens) {
  496     Error(parse_error("expected ${closing}", token_position(tokens, index)))
  497   } else {
  498     if tokens[index].text == closing {
  499       Ok(ParsedExprList(values, index + 1))
  500     } else {
  501       if tokens[index].text == "," {
  502         match parse_expression(tokens, index + 1) {
  503           Ok(parsed) => parse_expression_list_tail(tokens, append(values, parsed.value), parsed.next, closing),
  504           Error(error) => Error(error)
  505         }
  506       } else {
  507         Error(parse_error("expected comma or ${closing}", tokens[index].position))
  508       }
  509     }
  510   }
  511 }
  512 
  513 pure parse_expression_list(tokens: [Token], index: Nat, closing: Str): Result[ParsedExprList,Diagnostic] {
  514   if index < len(tokens) && tokens[index].text == closing {
  515     values: [Expr] = []
  516     Ok(ParsedExprList(values, index + 1))
  517   } else {
  518     match parse_expression(tokens, index) {
  519       Ok(parsed) => {
  520         values: [Expr] = [parsed.value]
  521         parse_expression_list_tail(tokens, values, parsed.next, closing)
  522       },
  523       Error(error) => Error(error)
  524     }
  525   }
  526 }
  527 
  528 pure parse_pattern_bindings(tokens: [Token], bindings: [Str], index: Nat): Result[ParsedNameList,Diagnostic] {
  529   if index >= len(tokens) {
  530     Error(parse_error("expected closing pattern parenthesis", token_position(tokens, index)))
  531   } else {
  532     if tokens[index].text == ")" {
  533       Ok(ParsedNameList(bindings, index + 1))
  534     } else {
  535       if tokens[index].kind != Identifier() {
  536         Error(parse_error("expected pattern binding", tokens[index].position))
  537       } else {
  538         next: Nat = index + 1
  539         values: [Str] = append(bindings, tokens[index].text)
  540         if next >= len(tokens) {
  541           Error(parse_error("expected closing pattern parenthesis", token_position(tokens, next)))
  542         } else {
  543           if tokens[next].text == ")" {
  544             Ok(ParsedNameList(values, next + 1))
  545           } else {
  546             if tokens[next].text == "," {
  547               if next + 1 < len(tokens) && tokens[next + 1].text == ")" {
  548                 Error(parse_error("expected pattern binding", tokens[next + 1].position))
  549               } else {
  550                 parse_pattern_bindings(tokens, values, next + 1)
  551               }
  552             } else {
  553               Error(parse_error("expected comma or closing pattern parenthesis", tokens[next].position))
  554             }
  555           }
  556         }
  557       }
  558     }
  559   }
  560 }
  561 
  562 pure parse_match_arm_body(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  563   if index < len(tokens) && tokens[index].text == "{" {
  564     match parse_block(tokens, index) {
  565       Ok(block) => Ok(ParsedExpr(located_expression(tokens, index, block.next, BlockExpr(block.value)), block.next)),
  566       Error(error) => Error(error)
  567     }
  568   } else {
  569     parse_expression(tokens, index)
  570   }
  571 }
  572 
  573 pure parse_match_arms(tokens: [Token], arms: [MatchArm], index: Nat): Result[ParsedMatchArmList,Diagnostic] {
  574   if index >= len(tokens) {
  575     Error(parse_error("expected closing match brace", token_position(tokens, index)))
  576   } else {
  577     if tokens[index].text == "}" {
  578       Ok(ParsedMatchArmList(arms, index + 1))
  579     } else {
  580       if tokens[index].kind != Identifier() {
  581         Error(parse_error("expected pattern variant", tokens[index].position))
  582       } else {
  583         match parse_reference_path(tokens, index) {
  584         Error(error) => Error(error),
  585         Ok(path) => {
  586         variant: Str = path.text
  587         opening_index: Nat = path.next
  588         if opening_index >= len(tokens) || tokens[opening_index].text != "(" {
  589           Error(parse_error("expected opening pattern parenthesis", token_position(tokens, opening_index)))
  590         } else {
  591           bindings: [Str] = []
  592           match parse_pattern_bindings(tokens, bindings, opening_index + 1) {
  593             Ok(parsed_bindings) => {
  594               if parsed_bindings.next >= len(tokens) || tokens[parsed_bindings.next].text != "=>" {
  595                 Error(parse_error("expected => after pattern", token_position(tokens, parsed_bindings.next)))
  596               } else {
  597                 match parse_match_arm_body(tokens, parsed_bindings.next + 1) {
  598                   Ok(body) => {
  599                     pattern: MatchPattern = MatchPattern(variant, parsed_bindings.values)
  600                     arm: MatchArm = MatchArm(pattern, body.value)
  601                     values: [MatchArm] = append(arms, arm)
  602                     if body.next >= len(tokens) {
  603                       Error(parse_error("expected closing match brace", token_position(tokens, body.next)))
  604                     } else {
  605                       if tokens[body.next].text == "," {
  606                         parse_match_arms(tokens, values, body.next + 1)
  607                       } else {
  608                         if tokens[body.next].text == "}" {
  609                           Ok(ParsedMatchArmList(values, body.next + 1))
  610                         } else {
  611                           Error(parse_error("expected comma or closing match brace", tokens[body.next].position))
  612                         }
  613                       }
  614                     }
  615                   },
  616                   Error(error) => Error(error)
  617                 }
  618               }
  619             },
  620             Error(error) => Error(error)
  621           }
  622         }
  623         }
  624         }
  625       }
  626     }
  627   }
  628 }
  629 
  630 pure parse_match_expression(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  631   match parse_expression(tokens, index + 1) {
  632     Ok(subject) => {
  633       if subject.next >= len(tokens) || tokens[subject.next].text != "{" {
  634         Error(parse_error("expected opening match brace", token_position(tokens, subject.next)))
  635       } else {
  636         arms: [MatchArm] = []
  637         match parse_match_arms(tokens, arms, subject.next + 1) {
  638           Ok(parsed_arms) => Ok(ParsedExpr(located_expression(tokens, index, parsed_arms.next, MatchExpr(subject.value, parsed_arms.values)), parsed_arms.next)),
  639           Error(error) => Error(error)
  640         }
  641       }
  642     },
  643     Error(error) => Error(error)
  644   }
  645 }
  646 
  647 pure parse_if_expression(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  648   match parse_expression(tokens, index + 1) {
  649     Ok(condition) => {
  650       match parse_block(tokens, condition.next) {
  651         Ok(yes) => {
  652           if yes.next < len(tokens) && tokens[yes.next].text == "else" {
  653             match parse_block(tokens, yes.next + 1) {
  654               Ok(no) => Ok(ParsedExpr(located_expression(tokens, index, no.next, IfExpr(condition.value, yes.value, no.value, true)), no.next)),
  655               Error(error) => Error(error)
  656             }
  657           } else {
  658             no: Block = Block([], NoBlockValue())
  659             Ok(ParsedExpr(located_expression(tokens, index, yes.next, IfExpr(condition.value, yes.value, no, false)), yes.next))
  660           }
  661         },
  662         Error(error) => Error(error)
  663       }
  664     },
  665     Error(error) => Error(error)
  666   }
  667 }
  668 
  669 pure parse_call_type_arguments(tokens: [Token], index: Nat): Result[ParsedTypeRefList,Diagnostic] {
  670   mut closing: Nat = index
  671   mut depth: Int = 0
  672   mut scanning: Bool = index < len(tokens) && tokens[index].text == "["
  673   while scanning && closing < len(tokens) {
  674     if tokens[closing].text == "[" { depth = depth + 1; }
  675     if tokens[closing].text == "]" { depth = depth - 1; if depth == 0 { scanning = false; } }
  676     if scanning { closing = closing + 1; }
  677   }
  678   if closing > index && closing + 1 < len(tokens) && tokens[closing + 1].text == "(" {
  679     parse_type_ref_list(tokens, index + 1)
  680   } else {
  681     Ok(ParsedTypeRefList([], index))
  682   }
  683 }
  684 
  685 pure parse_named_expression(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  686   match parse_call_type_arguments(tokens, index + 1) {
  687     Error(error) => Error(error),
  688     Ok(types) => {
  689       if types.next < len(tokens) && tokens[types.next].text == "(" {
  690         match parse_expression_list(tokens, types.next + 1, ")") {
  691           Ok(arguments) => Ok(ParsedExpr(located_expression(tokens, index, arguments.next, CallExpr(tokens[index].text, arguments.values, types.values)), arguments.next)),
  692           Error(error) => Error(error)
  693         }
  694       } else {
  695         Ok(ParsedExpr(located_expression(tokens, index, index + 1, NameExpr(tokens[index].text)), index + 1))
  696       }
  697     }
  698   }
  699 }
  700 
  701 pure parse_primary(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  702   if index >= len(tokens) {
  703     Error(parse_error("expected expression", token_position(tokens, index)))
  704   } else {
  705     token: Token = tokens[index]
  706     if token.text == "@" {
  707       if index + 1 < len(tokens) && tokens[index + 1].kind == Identifier() {
  708         match parse_reference_path(tokens, index + 1) {
  709           Error(error) => Error(error),
  710           Ok(path) => Ok(ParsedExpr(located_expression(tokens, index, path.next, FunctionExpr(path.text)), path.next))
  711         }
  712       } else {
  713         Error(parse_error("expected function name after @", token_position(tokens, index + 1)))
  714       }
  715     } else { if token.text == "match" {
  716       parse_match_expression(tokens, index)
  717     } else {
  718       if token.text == "if" {
  719         parse_if_expression(tokens, index)
  720       } else {
  721         if token.kind == Number() {
  722           Ok(ParsedExpr(located_expression(tokens, index, index + 1, NatExpr(nat_from_str(token.text))), index + 1))
  723         } else {
  724           if token.kind == DecimalNumber() {
  725             Ok(ParsedExpr(located_expression(tokens, index, index + 1, DecimalExpr(token.text)), index + 1))
  726           } else {
  727             if token.kind == StringLiteral() {
  728               Ok(ParsedExpr(located_expression(tokens, index, index + 1, StringExpr(token.text)), index + 1))
  729             } else {
  730               if token.text == "true" || token.text == "false" {
  731                 Ok(ParsedExpr(located_expression(tokens, index, index + 1, BoolExpr(token.text == "true")), index + 1))
  732               } else {
  733                 if token.kind == Identifier() {
  734                   parse_named_expression(tokens, index)
  735                 } else {
  736                   if token.text == "(" {
  737                     if index + 1 < len(tokens) && tokens[index + 1].text == ")" {
  738                       Ok(ParsedExpr(located_expression(tokens, index, index + 2, CallExpr("$unit", [], [])), index + 2))
  739                     } else { match parse_expression(tokens, index + 1) {
  740                       Ok(inner) => {
  741                         if inner.next < len(tokens) && tokens[inner.next].text == ")" {
  742                           Ok(ParsedExpr(located_expression(tokens, index, inner.next + 1, inner.value), inner.next + 1))
  743                         } else {
  744                           Error(parse_error("expected closing parenthesis", token_position(tokens, inner.next)))
  745                         }
  746                       },
  747                       Error(error) => Error(error)
  748                     }
  749                   } } else {
  750                     if token.text == "[" {
  751                       match parse_expression_list(tokens, index + 1, "]") {
  752                         Ok(items) => Ok(ParsedExpr(located_expression(tokens, index, items.next, ArrayExpr(items.values)), items.next)),
  753                         Error(error) => Error(error)
  754                       }
  755                     } else {
  756                       Error(parse_error("expected expression", token.position))
  757                     }
  758                   }
  759                 }
  760               }
  761             }
  762           }
  763         }
  764       }
  765     } }
  766   }
  767 }
  768 
  769 pure lowered_method_name(name: Str): Str {
  770   mut result: Str = name
  771   if name == "ends_with" { result = "$core_ends_with"; }
  772   if name == "first" { result = "$core_first"; }
  773   if name == "sort_by" { result = "$core_sort_by"; }
  774   if name == "parse_nat" { result = "nat_from_str"; }
  775   if name == "put" { result = "$method_put"; }
  776   if name == "has" { result = "$method_has"; }
  777   if name == "get" { result = "$method_get"; }
  778   if name == "add" { result = "$method_add"; }
  779   if name == "call" { result = "$method_call"; }
  780   if name == "map" { result = "$method_map"; }
  781   if name == "reduce" { result = "$method_reduce"; }
  782   result
  783 }
  784 
  785 pure parse_postfix_tail(tokens: [Token], left: Expr, index: Nat): Result[ParsedExpr,Diagnostic] {
  786   if index < len(tokens) && tokens[index].text == "[" {
  787     match parse_expression(tokens, index + 1) {
  788       Ok(parsed_index) => {
  789         if parsed_index.next < len(tokens) && tokens[parsed_index.next].text == "]" {
  790           parse_postfix_tail(tokens, extended_expression(tokens, left, parsed_index.next + 1, IndexExpr(left, parsed_index.value)), parsed_index.next + 1)
  791         } else {
  792           Error(parse_error("expected closing bracket", token_position(tokens, parsed_index.next)))
  793         }
  794       },
  795       Error(error) => Error(error)
  796     }
  797   } else {
  798     if index < len(tokens) && tokens[index].text == "." {
  799       if index + 1 < len(tokens) && tokens[index + 1].kind == Identifier() {
  800         name: Str = tokens[index + 1].text
  801         match parse_call_type_arguments(tokens, index + 2) {
  802           Error(error) => Error(error),
  803           Ok(types) => {
  804             if types.next < len(tokens) && tokens[types.next].text == "(" {
  805               match parse_expression_list(tokens, types.next + 1, ")") {
  806                 Ok(arguments) => {
  807                   parse_postfix_tail(tokens, extended_expression(tokens, left, arguments.next, DotCallExpr(left, name, arguments.values, types.values)), arguments.next)
  808                 },
  809                 Error(error) => Error(error)
  810               }
  811             } else {
  812               parse_postfix_tail(tokens, extended_expression(tokens, left, index + 2, FieldExpr(left, name)), index + 2)
  813             }
  814           }
  815         }
  816       } else {
  817         Error(parse_error("expected field name", token_position(tokens, index + 1)))
  818       }
  819     } else {
  820       Ok(ParsedExpr(left, index))
  821     }
  822   }
  823 }
  824 
  825 pure parse_postfix(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  826   match parse_primary(tokens, index) {
  827     Ok(primary) => parse_postfix_tail(tokens, primary.value, primary.next),
  828     Error(error) => Error(error)
  829   }
  830 }
  831 
  832 pure parse_unary(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  833   if index < len(tokens) && (tokens[index].text == "-" || tokens[index].text == "!" || tokens[index].text == "await") {
  834     operator: Str = tokens[index].text
  835     match parse_unary(tokens, index + 1) {
  836       Ok(operand) => Ok(ParsedExpr(located_expression(tokens, index, operand.next, UnaryExpr(operator, operand.value)), operand.next)),
  837       Error(error) => Error(error)
  838     }
  839   } else {
  840     parse_postfix(tokens, index)
  841   }
  842 }
  843 
  844 pure parse_product_tail(tokens: [Token], left: Expr, index: Nat): Result[ParsedExpr,Diagnostic] {
  845   if index < len(tokens) && (tokens[index].text == "*" || tokens[index].text == "/" || tokens[index].text == "%") {
  846     operator: Str = tokens[index].text
  847     match parse_unary(tokens, index + 1) {
  848       Ok(right) => parse_product_tail(tokens, extended_expression(tokens, left, right.next, BinaryExpr(operator, left, right.value)), right.next),
  849       Error(error) => Error(error)
  850     }
  851   } else {
  852     Ok(ParsedExpr(left, index))
  853   }
  854 }
  855 
  856 pure parse_product(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  857   match parse_unary(tokens, index) {
  858     Ok(left) => parse_product_tail(tokens, left.value, left.next),
  859     Error(error) => Error(error)
  860   }
  861 }
  862 
  863 pure parse_sum_tail(tokens: [Token], left: Expr, index: Nat): Result[ParsedExpr,Diagnostic] {
  864   if index < len(tokens) && (tokens[index].text == "+" || tokens[index].text == "-") {
  865     operator: Str = tokens[index].text
  866     match parse_product(tokens, index + 1) {
  867       Ok(right) => parse_sum_tail(tokens, extended_expression(tokens, left, right.next, BinaryExpr(operator, left, right.value)), right.next),
  868       Error(error) => Error(error)
  869     }
  870   } else {
  871     Ok(ParsedExpr(left, index))
  872   }
  873 }
  874 
  875 pure parse_sum(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  876   match parse_product(tokens, index) {
  877     Ok(left) => parse_sum_tail(tokens, left.value, left.next),
  878     Error(error) => Error(error)
  879   }
  880 }
  881 
  882 pure parse_comparison_tail(tokens: [Token], left: Expr, index: Nat): Result[ParsedExpr,Diagnostic] {
  883   if index < len(tokens) && (tokens[index].text == "<" || tokens[index].text == "<=" || tokens[index].text == ">" || tokens[index].text == ">=") {
  884     operator: Str = tokens[index].text
  885     match parse_sum(tokens, index + 1) {
  886       Ok(right) => parse_comparison_tail(tokens, extended_expression(tokens, left, right.next, BinaryExpr(operator, left, right.value)), right.next),
  887       Error(error) => Error(error)
  888     }
  889   } else {
  890     Ok(ParsedExpr(left, index))
  891   }
  892 }
  893 
  894 pure parse_comparison(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  895   match parse_sum(tokens, index) {
  896     Ok(left) => parse_comparison_tail(tokens, left.value, left.next),
  897     Error(error) => Error(error)
  898   }
  899 }
  900 
  901 pure parse_equality_tail(tokens: [Token], left: Expr, index: Nat): Result[ParsedExpr,Diagnostic] {
  902   if index < len(tokens) && (tokens[index].text == "==" || tokens[index].text == "!=") {
  903     operator: Str = tokens[index].text
  904     match parse_comparison(tokens, index + 1) {
  905       Ok(right) => parse_equality_tail(tokens, extended_expression(tokens, left, right.next, BinaryExpr(operator, left, right.value)), right.next),
  906       Error(error) => Error(error)
  907     }
  908   } else {
  909     Ok(ParsedExpr(left, index))
  910   }
  911 }
  912 
  913 pure parse_equality(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  914   match parse_comparison(tokens, index) {
  915     Ok(left) => parse_equality_tail(tokens, left.value, left.next),
  916     Error(error) => Error(error)
  917   }
  918 }
  919 
  920 pure parse_and_tail(tokens: [Token], left: Expr, index: Nat): Result[ParsedExpr,Diagnostic] {
  921   if index < len(tokens) && tokens[index].text == "&&" {
  922     match parse_equality(tokens, index + 1) {
  923       Ok(right) => parse_and_tail(tokens, extended_expression(tokens, left, right.next, BinaryExpr("&&", left, right.value)), right.next),
  924       Error(error) => Error(error)
  925     }
  926   } else {
  927     Ok(ParsedExpr(left, index))
  928   }
  929 }
  930 
  931 pure parse_and(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  932   match parse_equality(tokens, index) {
  933     Ok(left) => parse_and_tail(tokens, left.value, left.next),
  934     Error(error) => Error(error)
  935   }
  936 }
  937 
  938 pure parse_or_tail(tokens: [Token], left: Expr, index: Nat): Result[ParsedExpr,Diagnostic] {
  939   if index < len(tokens) && tokens[index].text == "||" {
  940     match parse_and(tokens, index + 1) {
  941       Ok(right) => parse_or_tail(tokens, extended_expression(tokens, left, right.next, BinaryExpr("||", left, right.value)), right.next),
  942       Error(error) => Error(error)
  943     }
  944   } else {
  945     Ok(ParsedExpr(left, index))
  946   }
  947 }
  948 
  949 pure parse_or(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  950   match parse_and(tokens, index) {
  951     Ok(left) => parse_or_tail(tokens, left.value, left.next),
  952     Error(error) => Error(error)
  953   }
  954 }
  955 
  956 pure parse_range_tail(tokens: [Token], left: Expr, index: Nat): Result[ParsedExpr,Diagnostic] {
  957   if index < len(tokens) && tokens[index].text == ".." {
  958     match parse_or(tokens, index + 1) {
  959       Ok(right) => parse_range_tail(tokens, extended_expression(tokens, left, right.next, BinaryExpr("..", left, right.value)), right.next),
  960       Error(error) => Error(error)
  961     }
  962   } else {
  963     Ok(ParsedExpr(left, index))
  964   }
  965 }
  966 
  967 pure parse_expression(tokens: [Token], index: Nat): Result[ParsedExpr,Diagnostic] {
  968   match parse_or(tokens, index) {
  969     Ok(left) => parse_range_tail(tokens, left.value, left.next),
  970     Error(error) => Error(error)
  971   }
  972 }
  973 
  974 pure parse_complete(tokens: [Token]): Result[Expr,Diagnostic] {
  975   match parse_expression(tokens, 0) {
  976     Ok(parsed) => {
  977       if parsed.next == len(tokens) {
  978         Ok(lower_legacy_expression(parsed.value))
  979       } else {
  980         Error(parse_error("unexpected token", tokens[parsed.next].position))
  981       }
  982     },
  983     Error(error) => Error(error)
  984   }
  985 }
  986 
  987 pure parse_while_statement(tokens: [Token], statements: [Statement], index: Nat): Result[ParsedBlock,Diagnostic] {
  988   match parse_expression(tokens, index + 1) {
  989     Ok(condition) => {
  990       match parse_block(tokens, condition.next) {
  991         Ok(body) => {
  992           next: Nat = if body.next < len(tokens) && tokens[body.next].text == ";" { body.next + 1 } else { body.next }
  993           statement: Statement = WhileStatement(condition.value, body.value)
  994           parse_block_items(tokens, append(statements, statement), next)
  995         },
  996         Error(error) => Error(error)
  997       }
  998     },
  999     Error(error) => Error(error)
 1000   }
 1001 }
 1002 
 1003 pure parse_for_statement(tokens: [Token], statements: [Statement], index: Nat): Result[ParsedBlock,Diagnostic] {
 1004   variable_index: Nat = index + 1
 1005   if variable_index >= len(tokens) || tokens[variable_index].kind != Identifier() {
 1006     Error(parse_error("expected loop variable", token_position(tokens, variable_index)))
 1007   } else {
 1008     in_index: Nat = variable_index + 1
 1009     if in_index >= len(tokens) || tokens[in_index].text != "in" {
 1010       Error(parse_error("expected in after loop variable", token_position(tokens, in_index)))
 1011     } else {
 1012       match parse_expression(tokens, in_index + 1) {
 1013         Ok(iterable) => {
 1014           match parse_block(tokens, iterable.next) {
 1015             Ok(body) => {
 1016               next: Nat = if body.next < len(tokens) && tokens[body.next].text == ";" { body.next + 1 } else { body.next }
 1017               statement: Statement = ForStatement(tokens[variable_index].text, iterable.value, body.value)
 1018               parse_block_items(tokens, append(statements, statement), next)
 1019             },
 1020             Error(error) => Error(error)
 1021           }
 1022         },
 1023         Error(error) => Error(error)
 1024       }
 1025     }
 1026   }
 1027 }
 1028 
 1029 pure parse_block_items(tokens: [Token], statements: [Statement], index: Nat): Result[ParsedBlock,Diagnostic] {
 1030   if index >= len(tokens) {
 1031     Error(parse_error("expected closing brace", token_position(tokens, index)))
 1032   } else {
 1033     if tokens[index].text == "}" {
 1034       Ok(ParsedBlock(Block(statements, NoBlockValue()), index + 1))
 1035     } else {
 1036       if tokens[index].text == "mut" ||
 1037           (tokens[index].kind == Identifier() && index + 1 < len(tokens) && tokens[index + 1].text == ":") {
 1038         mutable: Bool = tokens[index].text == "mut"
 1039         name_index: Nat = if mutable { index + 1 } else { index }
 1040         if name_index >= len(tokens) || tokens[name_index].kind != Identifier() {
 1041           Error(parse_error("expected binding name", token_position(tokens, name_index)))
 1042         } else {
 1043           name: Str = tokens[name_index].text
 1044           colon_index: Nat = name_index + 1
 1045           if colon_index >= len(tokens) || (tokens[colon_index].text != ":" && tokens[colon_index].text != "=") {
 1046             Error(parse_error("expected : or = after binding name", token_position(tokens, colon_index)))
 1047           } else {
 1048             annotation: Result[ParsedTypeRef,Diagnostic] = if tokens[colon_index].text == ":" {
 1049               parse_type_ref(tokens, colon_index + 1)
 1050             } else { Ok(ParsedTypeRef("", colon_index)) }
 1051             match annotation {
 1052               Ok(type_ref) => {
 1053                 if type_ref.next >= len(tokens) || tokens[type_ref.next].text != "=" {
 1054                   Error(parse_error("expected = after binding type", token_position(tokens, type_ref.next)))
 1055                 } else {
 1056                   match parse_expression(tokens, type_ref.next + 1) {
 1057                     Ok(value) => {
 1058                       initializer: Expr = value.value
 1059                       statement: Statement = BindingStatement(name, type_ref.text, mutable, initializer)
 1060                       if value.next < len(tokens) && tokens[value.next].text == ";" {
 1061                         parse_block_items(tokens, append(statements, statement), value.next + 1)
 1062                       } else {
 1063                         if value.next < len(tokens) && tokens[value.next].text == "}" {
 1064                           parse_block_items(tokens, append(statements, statement), value.next)
 1065                         } else {
 1066                           Error(parse_error("expected line break, semicolon, or closing brace after binding", token_position(tokens, value.next)))
 1067                         }
 1068                       }
 1069                     },
 1070                     Error(error) => Error(error)
 1071                   }
 1072                 }
 1073               },
 1074               Error(error) => Error(error)
 1075             }
 1076           }
 1077         }
 1078       } else {
 1079         if tokens[index].text == "while" {
 1080           parse_while_statement(tokens, statements, index)
 1081         } else {
 1082           if tokens[index].text == "for" {
 1083             parse_for_statement(tokens, statements, index)
 1084           } else {
 1085             if tokens[index].kind == Identifier() && index + 1 < len(tokens) && tokens[index + 1].text == "=" {
 1086               name: Str = tokens[index].text
 1087               match parse_expression(tokens, index + 2) {
 1088                 Ok(value) => {
 1089                   statement: Statement = AssignmentStatement(name, value.value)
 1090                   if value.next < len(tokens) && tokens[value.next].text == ";" {
 1091                     parse_block_items(tokens, append(statements, statement), value.next + 1)
 1092                   } else {
 1093                     if value.next < len(tokens) && tokens[value.next].text == "}" {
 1094                       parse_block_items(tokens, append(statements, statement), value.next)
 1095                     } else {
 1096                       Error(parse_error("expected line break, semicolon, or closing brace after assignment", token_position(tokens, value.next)))
 1097                     }
 1098                   }
 1099                 },
 1100                 Error(error) => Error(error)
 1101               }
 1102             } else {
 1103               match parse_expression(tokens, index) {
 1104                 Ok(expression) => {
 1105                   if expression.next < len(tokens) && tokens[expression.next].text == ";" {
 1106                     statement: Statement = ExpressionStatement(expression.value)
 1107                     parse_block_items(tokens, append(statements, statement), expression.next + 1)
 1108                   } else {
 1109                     if expression.next < len(tokens) && tokens[expression.next].text == "}" {
 1110                       Ok(ParsedBlock(Block(statements, TailBlockValue(expression.value)), expression.next + 1))
 1111                     } else {
 1112                       Error(parse_error("expected semicolon or closing brace", token_position(tokens, expression.next)))
 1113                     }
 1114                   }
 1115                 },
 1116                 Error(error) => Error(error)
 1117               }
 1118             }
 1119           }
 1120         }
 1121       }
 1122     }
 1123   }
 1124 }
 1125 
 1126 pure parse_block(tokens: [Token], index: Nat): Result[ParsedBlock,Diagnostic] {
 1127   if index >= len(tokens) || tokens[index].text != "{" {
 1128     Error(parse_error("expected opening brace", token_position(tokens, index)))
 1129   } else {
 1130     statements: [Statement] = []
 1131     parse_block_items(tokens, statements, index + 1)
 1132   }
 1133 }
 1134 
 1135 pure parse_block_complete(tokens: [Token]): Result[Block,Diagnostic] {
 1136   match parse_block(tokens, 0) {
 1137     Ok(parsed) => {
 1138       if parsed.next == len(tokens) {
 1139         Ok(parsed.value)
 1140       } else {
 1141         Error(parse_error("unexpected token after block", tokens[parsed.next].position))
 1142       }
 1143     },
 1144     Error(error) => Error(error)
 1145   }
 1146 }
 1147 
 1148 pure parse_type_declaration(tokens: [Token], index: Nat): Result[ParsedTopLevel,Diagnostic] {
 1149   name_index: Nat = index + 1
 1150   if name_index >= len(tokens) || tokens[name_index].kind != Identifier() {
 1151     Error(parse_error("expected type name", token_position(tokens, name_index)))
 1152   } else {
 1153     equals_index: Nat = name_index + 1
 1154     if equals_index >= len(tokens) || tokens[equals_index].text != "=" {
 1155       Error(parse_error("expected = after type name", token_position(tokens, equals_index)))
 1156     } else {
 1157       base_index: Nat = equals_index + 1
 1158       if base_index >= len(tokens) || tokens[base_index].kind != Identifier() {
 1159         Error(parse_error("expected guarded type base", token_position(tokens, base_index)))
 1160       } else {
 1161         where_index: Nat = base_index + 1
 1162         if where_index >= len(tokens) || tokens[where_index].text != "where" {
 1163           Error(parse_error("expected where after guarded type base", token_position(tokens, where_index)))
 1164         } else {
 1165           match parse_expression(tokens, where_index + 1) {
 1166             Ok(guard) => {
 1167               declaration: TopLevel = TypeDeclaration(tokens[name_index].text, tokens[base_index].text, guard.value)
 1168               if guard.next == len(tokens) {
 1169                 Ok(ParsedTopLevel(declaration, guard.next))
 1170               } else {
 1171                 if tokens[guard.next].text == ";" {
 1172                   Ok(ParsedTopLevel(declaration, guard.next + 1))
 1173                 } else {
 1174                   Error(parse_error("expected line break or semicolon after type declaration", token_position(tokens, guard.next)))
 1175                 }
 1176               }
 1177             },
 1178             Error(error) => Error(error)
 1179           }
 1180         }
 1181       }
 1182     }
 1183   }
 1184 }
 1185 
 1186 pure parse_record_fields(tokens: [Token], name: Str, parameters: [Str], fields: [RecordField], index: Nat): Result[ParsedTopLevel,Diagnostic] {
 1187   if index >= len(tokens) {
 1188     Error(parse_error("expected closing record brace", token_position(tokens, index)))
 1189   } else {
 1190     if tokens[index].text == "}" {
 1191       declaration: TopLevel = RecordDeclaration(name, parameters, fields)
 1192       Ok(ParsedTopLevel(declaration, index + 1))
 1193     } else {
 1194       if tokens[index].kind != Identifier() {
 1195         Error(parse_error("expected record field name", tokens[index].position))
 1196       } else {
 1197         field_name: Str = tokens[index].text
 1198         colon_index: Nat = index + 1
 1199         if colon_index >= len(tokens) || tokens[colon_index].text != ":" {
 1200           Error(parse_error("expected colon after record field name", token_position(tokens, colon_index)))
 1201         } else {
 1202           match parse_type_ref(tokens, colon_index + 1) {
 1203             Ok(type_ref) => {
 1204               field: RecordField = RecordField(field_name, type_ref.text)
 1205               values: [RecordField] = append(fields, field)
 1206               if type_ref.next >= len(tokens) {
 1207                 Error(parse_error("expected closing record brace", token_position(tokens, type_ref.next)))
 1208               } else {
 1209                 if tokens[type_ref.next].text == "," {
 1210                   parse_record_fields(tokens, name, parameters, values, type_ref.next + 1)
 1211                 } else {
 1212                   if tokens[type_ref.next].text == "}" {
 1213                     declaration: TopLevel = RecordDeclaration(name, parameters, values)
 1214                     Ok(ParsedTopLevel(declaration, type_ref.next + 1))
 1215                   } else {
 1216                     Error(parse_error("expected comma or closing record brace", tokens[type_ref.next].position))
 1217                   }
 1218                 }
 1219               }
 1220             },
 1221             Error(error) => Error(error)
 1222           }
 1223         }
 1224       }
 1225     }
 1226   }
 1227 }
 1228 
 1229 pure parse_record_declaration(tokens: [Token], index: Nat): Result[ParsedTopLevel,Diagnostic] {
 1230   name_index: Nat = index + 1
 1231   if name_index >= len(tokens) || tokens[name_index].kind != Identifier() {
 1232     Error(parse_error("expected record name", token_position(tokens, name_index)))
 1233   } else {
 1234     name: Str = tokens[name_index].text
 1235     match parse_generic_parameters(tokens, name_index + 1) {
 1236       Ok(parameters) => {
 1237         if parameters.next >= len(tokens) || tokens[parameters.next].text != "{" {
 1238           Error(parse_error("expected opening record brace", token_position(tokens, parameters.next)))
 1239         } else {
 1240           fields: [RecordField] = []
 1241           parse_record_fields(tokens, name, parameters.values, fields, parameters.next + 1)
 1242         }
 1243       },
 1244       Error(error) => Error(error)
 1245     }
 1246   }
 1247 }
 1248 
 1249 pure parse_enum_variants(tokens: [Token], name: Str, parameters: [Str], variants: [EnumVariant], index: Nat): Result[ParsedTopLevel,Diagnostic] {
 1250   if index >= len(tokens) {
 1251     Error(parse_error("expected closing enum brace", token_position(tokens, index)))
 1252   } else {
 1253     if tokens[index].text == "}" {
 1254       declaration: TopLevel = EnumDeclaration(name, parameters, variants)
 1255       Ok(ParsedTopLevel(declaration, index + 1))
 1256     } else {
 1257       if tokens[index].kind != Identifier() {
 1258         Error(parse_error("expected enum variant name", tokens[index].position))
 1259       } else {
 1260         variant_name: Str = tokens[index].text
 1261         payload_index: Nat = index + 1
 1262         if payload_index < len(tokens) && tokens[payload_index].text == "(" {
 1263           match parse_variant_payload(tokens, payload_index + 1) {
 1264             Ok(payload) => parse_enum_variant_tail(tokens, name, parameters, variants, variant_name, payload.values, payload.next),
 1265             Error(error) => Error(error)
 1266           }
 1267         } else {
 1268           payload: [Str] = []
 1269           parse_enum_variant_tail(tokens, name, parameters, variants, variant_name, payload, payload_index)
 1270         }
 1271       }
 1272     }
 1273   }
 1274 }
 1275 
 1276 pure parse_enum_variant_tail(tokens: [Token], name: Str, parameters: [Str], variants: [EnumVariant], variant_name: Str, payload: [Str], index: Nat): Result[ParsedTopLevel,Diagnostic] {
 1277   variant: EnumVariant = EnumVariant(variant_name, payload)
 1278   values: [EnumVariant] = append(variants, variant)
 1279   if index >= len(tokens) {
 1280     Error(parse_error("expected closing enum brace", token_position(tokens, index)))
 1281   } else {
 1282     if tokens[index].text == "," {
 1283       parse_enum_variants(tokens, name, parameters, values, index + 1)
 1284     } else {
 1285       if tokens[index].text == "}" {
 1286         declaration: TopLevel = EnumDeclaration(name, parameters, values)
 1287         Ok(ParsedTopLevel(declaration, index + 1))
 1288       } else {
 1289         Error(parse_error("expected comma or closing enum brace", tokens[index].position))
 1290       }
 1291     }
 1292   }
 1293 }
 1294 
 1295 pure parse_enum_declaration(tokens: [Token], index: Nat): Result[ParsedTopLevel,Diagnostic] {
 1296   name_index: Nat = index + 1
 1297   if name_index >= len(tokens) || tokens[name_index].kind != Identifier() {
 1298     Error(parse_error("expected enum name", token_position(tokens, name_index)))
 1299   } else {
 1300     name: Str = tokens[name_index].text
 1301     match parse_generic_parameters(tokens, name_index + 1) {
 1302       Ok(parameters) => {
 1303         if parameters.next >= len(tokens) || tokens[parameters.next].text != "{" {
 1304           Error(parse_error("expected opening enum brace", token_position(tokens, parameters.next)))
 1305         } else {
 1306           variants: [EnumVariant] = []
 1307           parse_enum_variants(tokens, name, parameters.values, variants, parameters.next + 1)
 1308         }
 1309       },
 1310       Error(error) => Error(error)
 1311     }
 1312   }
 1313 }
 1314 
 1315 pure parse_function_parameter_items(tokens: [Token], parameters: [FunctionParameter], index: Nat): Result[ParsedFunctionParameterList,Diagnostic] {
 1316   if index >= len(tokens) {
 1317     Error(parse_error("expected function parameter", token_position(tokens, index)))
 1318   } else {
 1319     if tokens[index].kind != Identifier() {
 1320       Error(parse_error("expected function parameter", tokens[index].position))
 1321     } else {
 1322       name: Str = tokens[index].text
 1323       colon_index: Nat = index + 1
 1324       if colon_index >= len(tokens) || tokens[colon_index].text != ":" {
 1325         Error(parse_error("expected colon after parameter name", token_position(tokens, colon_index)))
 1326       } else {
 1327         match parse_type_ref(tokens, colon_index + 1) {
 1328           Ok(type_ref) => {
 1329             parameter: FunctionParameter = FunctionParameter(name, type_ref.text)
 1330             values: [FunctionParameter] = append(parameters, parameter)
 1331             if type_ref.next >= len(tokens) {
 1332               Error(parse_error("expected closing function parenthesis", token_position(tokens, type_ref.next)))
 1333             } else {
 1334               if tokens[type_ref.next].text == ")" {
 1335                 Ok(ParsedFunctionParameterList(values, type_ref.next + 1))
 1336               } else {
 1337                 if tokens[type_ref.next].text == "," {
 1338                   parse_function_parameter_items(tokens, values, type_ref.next + 1)
 1339                 } else {
 1340                   Error(parse_error("expected comma or closing function parenthesis", tokens[type_ref.next].position))
 1341                 }
 1342               }
 1343             }
 1344           },
 1345           Error(error) => Error(error)
 1346         }
 1347       }
 1348     }
 1349   }
 1350 }
 1351 
 1352 pure parse_function_parameters(tokens: [Token], index: Nat): Result[ParsedFunctionParameterList,Diagnostic] {
 1353   if index < len(tokens) && tokens[index].text == ")" {
 1354     parameters: [FunctionParameter] = []
 1355     Ok(ParsedFunctionParameterList(parameters, index + 1))
 1356   } else {
 1357     parameters: [FunctionParameter] = []
 1358     parse_function_parameter_items(tokens, parameters, index)
 1359   }
 1360 }
 1361 
 1362 pure parse_function_declaration(tokens: [Token], index: Nat): Result[ParsedTopLevel,Diagnostic] {
 1363   is_pure: Bool = tokens[index].text == "pure"
 1364   is_async: Bool = tokens[index].text == "async"
 1365   name_index: Nat = if is_pure || is_async { index + 1 } else { index }
 1366   if name_index >= len(tokens) || tokens[name_index].kind != Identifier() {
 1367     Error(parse_error("expected function name", token_position(tokens, name_index)))
 1368   } else {
 1369     name: Str = tokens[name_index].text
 1370     match parse_generic_parameters(tokens, name_index + 1) {
 1371       Error(error) => Error(error),
 1372       Ok(generics) => {
 1373         opening_index: Nat = generics.next
 1374         if opening_index >= len(tokens) || tokens[opening_index].text != "(" {
 1375           Error(parse_error("expected opening function parenthesis", token_position(tokens, opening_index)))
 1376         } else {
 1377           match parse_function_parameters(tokens, opening_index + 1) {
 1378             Ok(parameters) => {
 1379               colon_index: Nat = parameters.next
 1380               if colon_index >= len(tokens) || tokens[colon_index].text != ":" {
 1381                 Error(parse_error("expected colon after function parameters", token_position(tokens, colon_index)))
 1382               } else {
 1383                 match parse_type_ref(tokens, colon_index + 1) {
 1384                   Ok(return_type) => {
 1385                     match parse_block(tokens, return_type.next) {
 1386                       Ok(body) => {
 1387                         declaration: TopLevel = FunctionDeclaration(name, parameters.values, return_type.text, is_pure, is_async, body.value, generics.values)
 1388                         Ok(ParsedTopLevel(declaration, body.next))
 1389                       },
 1390                       Error(error) => Error(error)
 1391                     }
 1392                   },
 1393                   Error(error) => Error(error)
 1394                 }
 1395               }
 1396             },
 1397             Error(error) => Error(error)
 1398           }
 1399         }
 1400       }
 1401     }
 1402   }
 1403 }
 1404 
 1405 // Source syntax stays separate from checked declaration identities. This metadata
 1406 // survives parsing before the staged execution boundary rejects new syntax.
 1407 record ImportSelector {
 1408   name: Str,
 1409   alias: Str,
 1410   span: SourceSpan
 1411 }
 1412 
 1413 enum ImportBindingSyntax {
 1414   NoImportBinding,
 1415   NamespaceImportBinding(Str, Bool),
 1416   SelectiveImportBinding([ImportSelector])
 1417 }
 1418 
 1419 record DeclarationSyntax {
 1420   span: SourceSpan,
 1421   is_public: Bool,
 1422   binding: ImportBindingSyntax
 1423 }
 1424 
 1425 record ParsedModule {
 1426   program: Program,
 1427   syntax: [DeclarationSyntax]
 1428 }
 1429 
 1430 record ParsedImportBinding {
 1431   binding: ImportBindingSyntax,
 1432   next: Nat
 1433 }
 1434 
 1435 pure default_import_alias(path: Str): Str {
 1436   mut start: Nat = 0
 1437   mut end: Nat = len(path)
 1438   mut cursor: Nat = 0
 1439   while cursor < len(path) {
 1440     if path[cursor] == "/" { start = cursor + 1 } else {}
 1441     if starts_with_at(path, ".panack", cursor) && cursor + 7 == len(path) { end = cursor } else {}
 1442     cursor = cursor + 1
 1443   }
 1444   slice(path, start, end)
 1445 }
 1446 
 1447 pure import_identifier(tokens: [Token], index: Nat): Bool {
 1448   index < len(tokens) && tokens[index].kind == Identifier() &&
 1449     tokens[index].text != "as" && tokens[index].text != "pub" && tokens[index].text != "import"
 1450 }
 1451 
 1452 pure parse_import_selectors(tokens: [Token], index: Nat, selectors: [ImportSelector]): Result[ParsedImportBinding,Diagnostic] {
 1453   if !import_identifier(tokens, index) {
 1454     Error(parse_error("expected imported declaration name", token_position(tokens, index)))
 1455   } else {
 1456     mut name: Str = tokens[index].text
 1457     mut alias: Str = tokens[index].text
 1458     mut missing_alias: Bool = false
 1459     mut cursor: Nat = index + 1
 1460     // Enum variants use a qualified selector; nested exported namespaces follow
 1461     // the same retained path representation and are resolved in a later slice.
 1462     while cursor < len(tokens) && tokens[cursor].text == "." && import_identifier(tokens, cursor + 1) {
 1463       alias = tokens[cursor + 1].text
 1464       name = name + "." + alias
 1465       cursor = cursor + 2
 1466     }
 1467     if cursor < len(tokens) && tokens[cursor].text == "as" {
 1468       cursor = cursor + 1
 1469       if import_identifier(tokens, cursor) { alias = tokens[cursor].text; cursor = cursor + 1 } else { missing_alias = true }
 1470     } else {}
 1471     if missing_alias {
 1472       Error(parse_error("expected import alias after as", token_position(tokens, cursor)))
 1473     } else {
 1474       selected: ImportSelector = ImportSelector(name, alias, SourceSpan(token_position(tokens, index), token_end_position(tokens, cursor)))
 1475       if cursor < len(tokens) && tokens[cursor].text == "}" {
 1476         Ok(ParsedImportBinding(SelectiveImportBinding(append(selectors, selected)), cursor + 1))
 1477       } else {
 1478         if cursor < len(tokens) && tokens[cursor].text == "," {
 1479           parse_import_selectors(tokens, cursor + 1, append(selectors, selected))
 1480         } else { Error(parse_error("expected ',' or '}' after import selector", token_position(tokens, cursor))) }
 1481       }
 1482     }
 1483   }
 1484 }
 1485 
 1486 pure parse_import_binding(tokens: [Token], index: Nat, path: Str): Result[ParsedImportBinding,Diagnostic] {
 1487   if index < len(tokens) && tokens[index].text == "as" {
 1488     if import_identifier(tokens, index + 1) {
 1489       Ok(ParsedImportBinding(NamespaceImportBinding(tokens[index + 1].text, true), index + 2))
 1490     } else { Error(parse_error("expected namespace alias after as", token_position(tokens, index + 1))) }
 1491   } else {
 1492     if index < len(tokens) && tokens[index].text == ":" {
 1493       if index + 2 < len(tokens) && tokens[index + 1].text == ":" && tokens[index + 2].text == "{" {
 1494         parse_import_selectors(tokens, index + 3, [])
 1495       } else { Error(parse_error("expected '::{...}' selective import", token_position(tokens, index))) }
 1496     } else { Ok(ParsedImportBinding(NamespaceImportBinding(default_import_alias(path), false), index)) }
 1497   }
 1498 }
 1499 
 1500 pure parse_nonimport_declaration(tokens: [Token], index: Nat): Result[ParsedTopLevel,Diagnostic] {
 1501   if index >= len(tokens) { Error(parse_error("expected top-level declaration", token_position(tokens, index))) }
 1502   else {
 1503     if tokens[index].text == "type" { parse_type_declaration(tokens, index) }
 1504     else { if tokens[index].text == "record" { parse_record_declaration(tokens, index) }
 1505     else { if tokens[index].text == "enum" { parse_enum_declaration(tokens, index) }
 1506     else { if tokens[index].kind == Identifier() { parse_function_declaration(tokens, index) }
 1507     else { Error(parse_error("expected top-level declaration", tokens[index].position)) } } } }
 1508   }
 1509 }
 1510 
 1511 pure parse_module_items(tokens: [Token], declarations: [TopLevel], syntax: [DeclarationSyntax], index: Nat): Result[ParsedModule,Diagnostic] {
 1512   if index == len(tokens) { Ok(ParsedModule(indexed_program(declarations), syntax)) }
 1513   else {
 1514     if tokens[index].text == ";" { parse_module_items(tokens, declarations, syntax, index + 1) }
 1515     else {
 1516       is_public: Bool = tokens[index].text == "pub"
 1517       start: Nat = if is_public { index + 1 } else { index }
 1518       if start < len(tokens) && tokens[start].text == "import" {
 1519         match parse_import_path(tokens, start + 1) {
 1520           Error(error) => Error(error),
 1521           Ok(path) => match parse_import_binding(tokens, path.next, path.text) {
 1522             Error(error) => Error(error),
 1523             Ok(parsed) => {
 1524               metadata: DeclarationSyntax = DeclarationSyntax(SourceSpan(token_position(tokens, index), token_end_position(tokens, parsed.next)), is_public, parsed.binding)
 1525               if parsed.next == len(tokens) || tokens[parsed.next].text == ";" {
 1526                 next: Nat = if parsed.next == len(tokens) { parsed.next } else { parsed.next + 1 }
 1527                 parse_module_items(tokens, append(declarations, ImportDeclaration(path.text)), append(syntax, metadata), next)
 1528               } else { Error(parse_error("expected line break or semicolon after import", token_position(tokens, parsed.next))) }
 1529             }
 1530           }
 1531         }
 1532       } else {
 1533         match parse_nonimport_declaration(tokens, start) {
 1534           Error(error) => Error(error),
 1535           Ok(parsed) => {
 1536             metadata: DeclarationSyntax = DeclarationSyntax(SourceSpan(token_position(tokens, index), token_end_position(tokens, parsed.next)), is_public, NoImportBinding())
 1537             parse_module_items(tokens, append(declarations, parsed.value), append(syntax, metadata), parsed.next)
 1538           }
 1539         }
 1540       }
 1541     }
 1542   }
 1543 }
 1544 
 1545 pure parse_module_complete(tokens: [Token]): Result[ParsedModule,Diagnostic] {
 1546   parse_module_items(tokens, [], [], 0)
 1547 }
 1548 
 1549 // Temporary bootstrap boundary: the checked/emitted AST still uses unqualified
 1550 // names. Never execute pub/alias/selective syntax with those flat semantics.
 1551 // Remove this gate only when every downstream consumer uses module identities
 1552 // and the compiler/stdlib/source fixtures have migrated with a fresh seed proof.
 1553 pure module_execution_diagnostics(module: ParsedModule): [Diagnostic] {
 1554   mut aliases: Set[Str] = set()
 1555   for syntax in module.syntax {
 1556     match syntax.binding {
 1557       NamespaceImportBinding(alias, explicit_alias) => { aliases = aliases.add(alias) },
 1558       NoImportBinding() => {}, SelectiveImportBinding(selectors) => {}
 1559     }
 1560   }
 1561   for declaration in module.program.declarations {
 1562     match declaration {
 1563       EnumDeclaration(name, parameters, variants) => { aliases = aliases.add(name) },
 1564       ImportDeclaration(path) => {}, TypeDeclaration(name, base, guard) => {},
 1565       RecordDeclaration(name, parameters, fields) => {},
 1566       FunctionDeclaration(name, parameters, return_type, is_pure, is_async, body, type_parameters) => {}
 1567     }
 1568   }
 1569   mut diagnostics: [Diagnostic] = []
 1570   mut index: Nat = 0
 1571   for syntax in module.syntax {
 1572     mut requires_namespaces: Bool = syntax.is_public || declaration_requires_namespaces(module.program.declarations[index], aliases, set())
 1573     match syntax.binding {
 1574       NoImportBinding() => {},
 1575       NamespaceImportBinding(alias, explicit_alias) => { requires_namespaces = requires_namespaces || explicit_alias },
 1576       SelectiveImportBinding(selectors) => { requires_namespaces = true }
 1577     }
 1578     if requires_namespaces {
 1579       diagnostics = append(diagnostics, Diagnostic("namespace syntax is parsed but execution is not yet supported (language namespace migration pending)", syntax.span.start))
 1580     }
 1581     index = index + 1
 1582   }
 1583   diagnostics
 1584 }
 1585 
 1586 pure parse_program_complete(tokens: [Token]): Result[Program,Diagnostic] {
 1587   match parse_module_complete(tokens) {
 1588     Error(error) => Error(error),
 1589     Ok(module) => {
 1590       diagnostics: [Diagnostic] = module_execution_diagnostics(module)
 1591       if len(diagnostics) > 0 { Error(diagnostics[0]) } else { Ok(lower_legacy_program(module.program)) }
 1592     }
 1593   }
 1594 }
 1595 
 1596 pure render_expr_list(expressions: [Expr]): Str {
 1597   mut output: Str = ""
 1598   mut first: Bool = true
 1599   for expression in expressions {
 1600     if first {
 1601       first = false
 1602     } else {
 1603       output = output + ", "
 1604     }
 1605     output = output + render_expr(expression)
 1606   }
 1607   output
 1608 }
 1609 
 1610 pure render_name_list(names: [Str]): Str {
 1611   mut output: Str = ""
 1612   mut first: Bool = true
 1613   for name in names {
 1614     if first {
 1615       first = false
 1616     } else {
 1617       output = output + ", "
 1618     }
 1619     output = output + name
 1620   }
 1621   output
 1622 }
 1623 
 1624 pure render_match_arm(arm: MatchArm): Str {
 1625   variant: Str = arm.pattern.variant
 1626   bindings_text: Str = render_name_list(arm.pattern.bindings)
 1627   body_text: Str = render_expr(arm.body)
 1628   "${variant}(${bindings_text}) => ${body_text}"
 1629 }
 1630 
 1631 pure render_match_arms(arms: [MatchArm]): Str {
 1632   mut output: Str = ""
 1633   mut first: Bool = true
 1634   for arm in arms {
 1635     if first {
 1636       first = false
 1637     } else {
 1638       output = output + ", "
 1639     }
 1640     output = output + render_match_arm(arm)
 1641   }
 1642   output
 1643 }
 1644 
 1645 pure render_expr(expression: Expr): Str {
 1646   match expression {
 1647     LocatedExpr(position, value) => render_expr(value),
 1648     NatExpr(value) => "${value}",
 1649     DecimalExpr(text) => text,
 1650     StringExpr(text) => text,
 1651     BoolExpr(value) => if value { "true" } else { "false" },
 1652     NameExpr(name) => name,
 1653     FunctionExpr(name) => "@${name}",
 1654     ArrayExpr(items) => {
 1655       items_text: Str = render_expr_list(items)
 1656       "[${items_text}]"
 1657     },
 1658     UnaryExpr(operator, operand) => {
 1659       operand_text: Str = render_expr(operand)
 1660       if operator == "await" { "(await ${operand_text})" } else { "(${operator}${operand_text})" }
 1661     },
 1662     BinaryExpr(operator, left, right) => {
 1663       left_text: Str = render_expr(left)
 1664       right_text: Str = render_expr(right)
 1665       "(${left_text} ${operator} ${right_text})"
 1666     },
 1667     CallExpr(name, arguments, type_arguments) => {
 1668       arguments_text: Str = render_expr_list(arguments)
 1669       types_text: Str = render_type_parameters(type_arguments)
 1670       "${name}${types_text}(${arguments_text})"
 1671     },
 1672     DotCallExpr(target, name, arguments, types) => render_expr(lower_legacy_expression(DotCallExpr(target, name, arguments, types))),
 1673     FieldExpr(target, field) => {
 1674       target_text: Str = render_expr(target)
 1675       "${target_text}.${field}"
 1676     },
 1677     IndexExpr(target, index) => {
 1678       target_text: Str = render_expr(target)
 1679       index_text: Str = render_expr(index)
 1680       "${target_text}[${index_text}]"
 1681     },
 1682     IfExpr(condition, yes, no, has_else) => {
 1683       condition_text: Str = render_expr(condition)
 1684       yes_text: Str = render_block(yes)
 1685       if has_else {
 1686         no_text: Str = render_block(no)
 1687         "if ${condition_text} ${yes_text} else ${no_text}"
 1688       } else {
 1689         "if ${condition_text} ${yes_text}"
 1690       }
 1691     },
 1692     BlockExpr(block) => render_block(block),
 1693     MatchExpr(subject, arms) => {
 1694       subject_text: Str = render_expr(subject)
 1695       arms_text: Str = render_match_arms(arms)
 1696       if len(arms_text) == 0 {
 1697         "match ${subject_text} {}"
 1698       } else {
 1699         "match ${subject_text} { ${arms_text} }"
 1700       }
 1701     }
 1702   }
 1703 }
 1704 
 1705 pure render_statement(statement: Statement): Str {
 1706   match statement {
 1707     BindingStatement(name, type_name, mutable, value) => {
 1708       prefix: Str = if mutable { "mut " } else { "" }
 1709       value_text: Str = render_expr(value)
 1710       annotation: Str = if len(type_name) > 0 { ": ${type_name}" } else { "" }
 1711       "${prefix}${name}${annotation} = ${value_text};"
 1712     },
 1713     AssignmentStatement(name, value) => {
 1714       value_text: Str = render_expr(value)
 1715       "${name} = ${value_text};"
 1716     },
 1717     ExpressionStatement(expression) => {
 1718       expression_text: Str = render_expr(expression)
 1719       "${expression_text};"
 1720     },
 1721     WhileStatement(condition, body) => {
 1722       condition_text: Str = render_expr(condition)
 1723       body_text: Str = render_block(body)
 1724       "while ${condition_text} ${body_text}"
 1725     },
 1726     ForStatement(variable, iterable, body) => {
 1727       iterable_text: Str = render_expr(iterable)
 1728       body_text: Str = render_block(body)
 1729       "for ${variable} in ${iterable_text} ${body_text}"
 1730     }
 1731   }
 1732 }
 1733 
 1734 pure render_block(block: Block): Str {
 1735   mut contents: Str = ""
 1736   for statement in block.statements {
 1737     if len(contents) > 0 {
 1738       contents = contents + " "
 1739     } else {
 1740     }
 1741     contents = contents + render_statement(statement)
 1742   }
 1743   match block.value {
 1744     NoBlockValue() => {},
 1745     TailBlockValue(value) => {
 1746       if len(contents) > 0 {
 1747         contents = contents + " "
 1748       } else {
 1749       }
 1750       contents = contents + render_expr(value)
 1751     }
 1752   }
 1753   if len(contents) == 0 { "{}" } else { "{ ${contents} }" }
 1754 }
 1755 
 1756 pure render_type_parameters(parameters: [Str]): Str {
 1757   if len(parameters) == 0 {
 1758     ""
 1759   } else {
 1760     parameters_text: Str = render_type_ref_list(parameters)
 1761     "[${parameters_text}]"
 1762   }
 1763 }
 1764 
 1765 pure render_record_fields(fields: [RecordField]): Str {
 1766   mut output: Str = ""
 1767   mut first: Bool = true
 1768   for field in fields {
 1769     if first {
 1770       first = false
 1771     } else {
 1772       output = output + ", "
 1773     }
 1774     field_name: Str = field.name
 1775     type_name: Str = field.type_name
 1776     output = output + "${field_name}: ${type_name}"
 1777   }
 1778   output
 1779 }
 1780 
 1781 pure render_record_declaration(name: Str, parameters: [Str], fields: [RecordField]): Str {
 1782   parameters_text: Str = render_type_parameters(parameters)
 1783   fields_text: Str = render_record_fields(fields)
 1784   if len(fields_text) == 0 {
 1785     "record ${name}${parameters_text} {}"
 1786   } else {
 1787     "record ${name}${parameters_text} { ${fields_text} }"
 1788   }
 1789 }
 1790 
 1791 pure render_enum_variants(variants: [EnumVariant]): Str {
 1792   mut output: Str = ""
 1793   mut first: Bool = true
 1794   for variant in variants {
 1795     if first {
 1796       first = false
 1797     } else {
 1798       output = output + ", "
 1799     }
 1800     variant_name: Str = variant.name
 1801     if len(variant.payload) == 0 {
 1802       output = output + variant_name
 1803     } else {
 1804       payload_text: Str = render_type_ref_list(variant.payload)
 1805       output = output + "${variant_name}(${payload_text})"
 1806     }
 1807   }
 1808   output
 1809 }
 1810 
 1811 pure render_enum_declaration(name: Str, parameters: [Str], variants: [EnumVariant]): Str {
 1812   parameters_text: Str = render_type_parameters(parameters)
 1813   variants_text: Str = render_enum_variants(variants)
 1814   if len(variants_text) == 0 {
 1815     "enum ${name}${parameters_text} {}"
 1816   } else {
 1817     "enum ${name}${parameters_text} { ${variants_text} }"
 1818   }
 1819 }
 1820 
 1821 pure render_function_parameters(parameters: [FunctionParameter]): Str {
 1822   mut output: Str = ""
 1823   mut first: Bool = true
 1824   for parameter in parameters {
 1825     if first {
 1826       first = false
 1827     } else {
 1828       output = output + ", "
 1829     }
 1830     parameter_name: Str = parameter.name
 1831     type_name: Str = parameter.type_name
 1832     output = output + "${parameter_name}: ${type_name}"
 1833   }
 1834   output
 1835 }
 1836 
 1837 pure render_function_declaration(name: Str, parameters: [FunctionParameter], return_type: Str, is_pure: Bool, body: Block): Str {
 1838   prefix: Str = if is_pure { "pure " } else { "" }
 1839   parameters_text: Str = render_function_parameters(parameters)
 1840   body_text: Str = render_block(body)
 1841   "${prefix}${name}(${parameters_text}): ${return_type} ${body_text}"
 1842 }
 1843 
 1844 pure render_top_level(declaration: TopLevel): Str {
 1845   match declaration {
 1846     ImportDeclaration(path) => "import \"${path}\";",
 1847     TypeDeclaration(name, base, guard) => {
 1848       guard_text: Str = render_expr(guard)
 1849       "type ${name} = ${base} where ${guard_text};"
 1850     },
 1851     RecordDeclaration(name, parameters, fields) => render_record_declaration(name, parameters, fields),
 1852     EnumDeclaration(name, parameters, variants) => render_enum_declaration(name, parameters, variants),
 1853     FunctionDeclaration(name, parameters, return_type, is_pure, is_async, body, type_parameters) => {
 1854       types_text: Str = render_type_parameters(type_parameters)
 1855       rendered: Str = render_function_declaration("${name}${types_text}", parameters, return_type, is_pure, body)
 1856       if is_async { "async ${rendered}" } else { rendered }
 1857     }
 1858   }
 1859 }
 1860 
 1861 pure render_program(program: Program): Str {
 1862   mut output: Str = ""
 1863   for declaration in program.declarations {
 1864     if len(output) > 0 {
 1865       output = output + " "
 1866     } else {
 1867     }
 1868     output = output + render_top_level(declaration)
 1869   }
 1870   output
 1871 }
 1872 
 1873 pure parse_source(source: Str): Str {
 1874   match lex(source) {
 1875     Ok(tokens) => {
 1876       match parse_complete(tokens) {
 1877         Ok(expression) => render_expr(expression),
 1878         Error(error) => error.message
 1879       }
 1880     },
 1881     Error(errors) => "lexing failed"
 1882   }
 1883 }
 1884 
 1885 pure parse_block_source(source: Str): Str {
 1886   match lex(source) {
 1887     Ok(tokens) => {
 1888       match parse_block_complete(tokens) {
 1889         Ok(block) => render_block(block),
 1890         Error(error) => error.message
 1891       }
 1892     },
 1893     Error(errors) => "lexing failed"
 1894   }
 1895 }
 1896 
 1897 pure parse_program_source(source: Str): Str {
 1898   match lex(source) {
 1899     Ok(tokens) => {
 1900       match parse_program_complete(tokens) {
 1901         Ok(program) => render_program(program),
 1902         Error(error) => error.message
 1903       }
 1904     },
 1905     Error(errors) => "lexing failed"
 1906   }
 1907 }
 1908 
 1909 pure parse_type_source(source: Str): Str {
 1910   match lex(source) {
 1911     Ok(tokens) => {
 1912       match parse_type_complete(tokens) {
 1913         Ok(type_name) => type_name,
 1914         Error(error) => error.message
 1915       }
 1916     },
 1917     Error(errors) => "lexing failed"
 1918   }
 1919 }
 1920 
 1921 // Preserve token positions while hiding implementation function identities.
 1922 pure core_tokens(tokens: [Token]): [Token] {
 1923   mut result: [Token] = []
 1924   for token in tokens {
 1925     name: Str = if token.kind == Identifier() &&
 1926       (token.text == "core_ends_with" || token.text == "core_first" || token.text == "core_sort_by") {
 1927       "$" + token.text
 1928     } else { token.text }
 1929     result = result.append(Token(token.kind, name, token.start, token.end,
 1930       token.position, token.end_line, token.end_column))
 1931   }
 1932   result
 1933 }
 1934 
 1935 // Temporary bootstrap lowering. Raw ParsedModule trees retain dot calls; only
 1936 // the gated legacy frontend may convert them to receiver-first calls.
 1937 pure lower_legacy_expressions(values: [Expr]): [Expr] {
 1938   mut result: [Expr] = []
 1939   for value in values { result = append(result, lower_legacy_expression(value)) }
 1940   result
 1941 }
 1942 
 1943 pure lower_legacy_expression(value: Expr): Expr {
 1944   match value {
 1945     LocatedExpr(span, inner) => LocatedExpr(span, lower_legacy_expression(inner)),
 1946     DotCallExpr(target, name, arguments, types) => CallExpr(lowered_method_name(name), concat([lower_legacy_expression(target)], lower_legacy_expressions(arguments)), types),
 1947     ArrayExpr(items) => ArrayExpr(lower_legacy_expressions(items)),
 1948     UnaryExpr(operator, operand) => UnaryExpr(operator, lower_legacy_expression(operand)),
 1949     BinaryExpr(operator, left, right) => BinaryExpr(operator, lower_legacy_expression(left), lower_legacy_expression(right)),
 1950     CallExpr(name, arguments, types) => CallExpr(name, lower_legacy_expressions(arguments), types),
 1951     FieldExpr(target, field) => FieldExpr(lower_legacy_expression(target), field),
 1952     IndexExpr(target, index) => IndexExpr(lower_legacy_expression(target), lower_legacy_expression(index)),
 1953     IfExpr(condition, yes, no, has_else) => IfExpr(lower_legacy_expression(condition), lower_legacy_block(yes), lower_legacy_block(no), has_else),
 1954     BlockExpr(block) => BlockExpr(lower_legacy_block(block)),
 1955     MatchExpr(subject, arms) => {
 1956       mut result: [MatchArm] = []
 1957       for arm in arms { result = append(result, MatchArm(arm.pattern, lower_legacy_expression(arm.body))) }
 1958       MatchExpr(lower_legacy_expression(subject), result)
 1959     },
 1960     NatExpr(number) => value, DecimalExpr(text) => value, StringExpr(text) => value,
 1961     BoolExpr(flag) => value, NameExpr(name) => value, FunctionExpr(name) => value
 1962   }
 1963 }
 1964 
 1965 pure lower_legacy_block(block: Block): Block {
 1966   mut statements: [Statement] = []
 1967   for statement in block.statements {
 1968     converted: Statement = match statement {
 1969       BindingStatement(name, type_name, mutable, value) => BindingStatement(name, type_name, mutable, lower_legacy_expression(value)),
 1970       AssignmentStatement(name, value) => AssignmentStatement(name, lower_legacy_expression(value)),
 1971       ExpressionStatement(value) => ExpressionStatement(lower_legacy_expression(value)),
 1972       WhileStatement(condition, body) => WhileStatement(lower_legacy_expression(condition), lower_legacy_block(body)),
 1973       ForStatement(name, values, body) => ForStatement(name, lower_legacy_expression(values), lower_legacy_block(body))
 1974     }
 1975     statements = append(statements, converted)
 1976   }
 1977   tail: BlockValue = match block.value {
 1978     NoBlockValue() => NoBlockValue(),
 1979     TailBlockValue(value) => TailBlockValue(lower_legacy_expression(value))
 1980   }
 1981   Block(statements, tail)
 1982 }
 1983 
 1984 pure lower_legacy_program(program: Program): Program {
 1985   mut declarations: [TopLevel] = []
 1986   for declaration in program.declarations {
 1987     converted: TopLevel = match declaration {
 1988       TypeDeclaration(name, base, guard) => TypeDeclaration(name, base, lower_legacy_expression(guard)),
 1989       FunctionDeclaration(name, parameters, return_type, is_pure, is_async, body, type_parameters) => FunctionDeclaration(name, parameters, return_type, is_pure, is_async, lower_legacy_block(body), type_parameters),
 1990       ImportDeclaration(path) => declaration,
 1991       RecordDeclaration(name, parameters, fields) => declaration,
 1992       EnumDeclaration(name, parameters, variants) => declaration
 1993     }
 1994     declarations = append(declarations, converted)
 1995   }
 1996   indexed_program(declarations)
 1997 }
 1998 
 1999 pure reference_head(name: Str): Str {
 2000   mut end: Nat = 0
 2001   while end < len(name) && name[end] != "." { end = end + 1 }
 2002   slice(name, 0, end)
 2003 }
 2004 
 2005 pure reference_tail(name: Str): Str {
 2006   head: Str = reference_head(name)
 2007   if len(head) < len(name) { slice(name, len(head) + 1, len(name)) } else { "" }
 2008 }
 2009 
 2010 pure expression_reference_path(expression: Expr): Str {
 2011   match expression {
 2012     LocatedExpr(span, value) => expression_reference_path(value),
 2013     NameExpr(name) => name,
 2014     FieldExpr(target, field) => {
 2015       path: Str = expression_reference_path(target)
 2016       if path == "" { "" } else { path + "." + field }
 2017     },
 2018     NatExpr(value) => "", DecimalExpr(text) => "", StringExpr(text) => "", BoolExpr(value) => "",
 2019     FunctionExpr(name) => "", ArrayExpr(items) => "", UnaryExpr(operator, operand) => "",
 2020     BinaryExpr(operator, left, right) => "", CallExpr(name, arguments, types) => "",
 2021     DotCallExpr(target, name, arguments, types) => "", IndexExpr(target, index) => "",
 2022     IfExpr(condition, yes, no, has_else) => "", BlockExpr(block) => "", MatchExpr(subject, arms) => ""
 2023   }
 2024 }
 2025 
 2026 pure type_has_qualification(name: Str): Bool {
 2027   mut found: Bool = false
 2028   mut index: Nat = 0
 2029   while index < len(name) { if name[index] == "." { found = true }; index = index + 1 }
 2030   found
 2031 }
 2032 
 2033 // Only candidate namespace roots need membership in the gate's lexical set.
 2034 // Tracking unrelated locals changes no lookup and copies unnecessary sets.
 2035 pure expression_requires_namespaces(expression: Expr, aliases: Set[Str], locals: Set[Str]): Bool {
 2036   match expression {
 2037     LocatedExpr(span, value) => expression_requires_namespaces(value, aliases, locals),
 2038     DotCallExpr(target, name, arguments, types) => {
 2039       mut required: Bool = (aliases.has(reference_head(expression_reference_path(target))) && !locals.has(reference_head(expression_reference_path(target)))) || expression_requires_namespaces(target, aliases, locals)
 2040       for argument in arguments { required = required || expression_requires_namespaces(argument, aliases, locals) }
 2041       for type_name in types { required = required || type_has_qualification(type_name) }
 2042       required
 2043     },
 2044     FieldExpr(target, field) => (aliases.has(reference_head(expression_reference_path(target))) && !locals.has(reference_head(expression_reference_path(target)))) || expression_requires_namespaces(target, aliases, locals),
 2045     FunctionExpr(name) => type_has_qualification(name),
 2046     CallExpr(name, arguments, types) => {
 2047       mut required: Bool = type_has_qualification(name)
 2048       for argument in arguments { required = required || expression_requires_namespaces(argument, aliases, locals) }
 2049       for type_name in types { required = required || type_has_qualification(type_name) }
 2050       required
 2051     },
 2052     ArrayExpr(items) => { mut required: Bool = false; for item in items { required = required || expression_requires_namespaces(item, aliases, locals) }; required },
 2053     UnaryExpr(operator, operand) => expression_requires_namespaces(operand, aliases, locals),
 2054     BinaryExpr(operator, left, right) => expression_requires_namespaces(left, aliases, locals) || expression_requires_namespaces(right, aliases, locals),
 2055     IndexExpr(target, index) => expression_requires_namespaces(target, aliases, locals) || expression_requires_namespaces(index, aliases, locals),
 2056     IfExpr(condition, yes, no, has_else) => expression_requires_namespaces(condition, aliases, locals) || block_requires_namespaces(yes, aliases, locals) || block_requires_namespaces(no, aliases, locals),
 2057     BlockExpr(block) => block_requires_namespaces(block, aliases, locals),
 2058     MatchExpr(subject, arms) => {
 2059       mut required: Bool = expression_requires_namespaces(subject, aliases, locals)
 2060       for arm in arms {
 2061         mut arm_locals: Set[Str] = locals
 2062         for name in arm.pattern.bindings { if aliases.has(name) { arm_locals = arm_locals.add(name) } }
 2063         required = required || type_has_qualification(arm.pattern.variant) || expression_requires_namespaces(arm.body, aliases, arm_locals)
 2064       }
 2065       required
 2066     },
 2067     NatExpr(value) => false, DecimalExpr(text) => false, StringExpr(text) => false,
 2068     BoolExpr(value) => false, NameExpr(name) => false
 2069   }
 2070 }
 2071 
 2072 pure block_requires_namespaces(block: Block, aliases: Set[Str], locals: Set[Str]): Bool {
 2073   mut required: Bool = false
 2074   mut visible: Set[Str] = locals
 2075   for statement in block.statements {
 2076     match statement {
 2077       BindingStatement(name, type_name, mutable, value) => {
 2078         required = required || type_has_qualification(type_name) || expression_requires_namespaces(value, aliases, visible)
 2079         if aliases.has(name) { visible = visible.add(name) }
 2080       },
 2081       AssignmentStatement(name, value) => {
 2082         required = required || expression_requires_namespaces(value, aliases, visible)
 2083         if aliases.has(name) { visible = visible.add(name) }
 2084       },
 2085       ExpressionStatement(value) => { required = required || expression_requires_namespaces(value, aliases, visible) },
 2086       WhileStatement(condition, body) => { required = required || expression_requires_namespaces(condition, aliases, visible) || block_requires_namespaces(body, aliases, visible) },
 2087       ForStatement(name, values, body) => { required = required || expression_requires_namespaces(values, aliases, visible) || block_requires_namespaces(body, aliases, if aliases.has(name) { visible.add(name) } else { visible }) }
 2088     }
 2089   }
 2090   required || match block.value {
 2091     NoBlockValue() => false,
 2092     TailBlockValue(value) => expression_requires_namespaces(value, aliases, visible)
 2093   }
 2094 }
 2095 
 2096 pure declaration_requires_namespaces(declaration: TopLevel, aliases: Set[Str], locals: Set[Str]): Bool {
 2097   match declaration {
 2098     ImportDeclaration(path) => false,
 2099     TypeDeclaration(name, base, guard) => type_has_qualification(base) || expression_requires_namespaces(guard, aliases, if aliases.has("value") { locals.add("value") } else { locals }),
 2100     RecordDeclaration(name, parameters, fields) => {
 2101       mut required: Bool = false
 2102       for field in fields { required = required || type_has_qualification(field.type_name) }
 2103       required
 2104     },
 2105     EnumDeclaration(name, parameters, variants) => {
 2106       mut required: Bool = false
 2107       for variant in variants { for type_name in variant.payload { required = required || type_has_qualification(type_name) } }
 2108       required
 2109     },
 2110     FunctionDeclaration(name, parameters, return_type, is_pure, is_async, body, type_parameters) => {
 2111       mut parameters_in_scope: Set[Str] = locals
 2112       for parameter in parameters { if aliases.has(parameter.name) { parameters_in_scope = parameters_in_scope.add(parameter.name) } }
 2113       mut required: Bool = type_has_qualification(return_type) || block_requires_namespaces(body, aliases, parameters_in_scope)
 2114       for parameter in parameters { required = required || type_has_qualification(parameter.type_name) }
 2115       required
 2116     }
 2117   }
 2118 }
 2119 

Functions

[
  {
    "id": "declaration/2",
    "name": "unlocated_expression",
    "line": 25,
    "state": "covered",
    "entries": "42899"
  },
  {
    "id": "declaration/11",
    "name": "indexed_program",
    "line": 90,
    "state": "covered",
    "entries": "1459"
  },
  {
    "id": "declaration/24",
    "name": "token_end_position",
    "line": 182,
    "state": "covered",
    "entries": "45447"
  },
  {
    "id": "declaration/25",
    "name": "located_expression",
    "line": 192,
    "state": "covered",
    "entries": "32643"
  },
  {
    "id": "declaration/26",
    "name": "expression_span",
    "line": 196,
    "state": "covered",
    "entries": "12170"
  },
  {
    "id": "declaration/27",
    "name": "extended_expression",
    "line": 209,
    "state": "covered",
    "entries": "10068"
  },
  {
    "id": "declaration/29",
    "name": "parse_error",
    "line": 221,
    "state": "covered",
    "entries": "105"
  },
  {
    "id": "declaration/30",
    "name": "string_token_value",
    "line": 225,
    "state": "covered",
    "entries": "87"
  },
  {
    "id": "declaration/31",
    "name": "token_position",
    "line": 249,
    "state": "covered",
    "entries": "35446"
  },
  {
    "id": "declaration/32",
    "name": "parse_logical_import_path_tail",
    "line": 261,
    "state": "covered",
    "entries": "309"
  },
  {
    "id": "declaration/33",
    "name": "parse_import_path",
    "line": 292,
    "state": "covered",
    "entries": "243"
  },
  {
    "id": "declaration/34",
    "name": "render_type_ref_list",
    "line": 308,
    "state": "covered",
    "entries": "620"
  },
  {
    "id": "declaration/35",
    "name": "parse_type_ref_list_tail",
    "line": 322,
    "state": "covered",
    "entries": "1009"
  },
  {
    "id": "declaration/36",
    "name": "parse_type_ref_list",
    "line": 341,
    "state": "covered",
    "entries": "656"
  },
  {
    "id": "declaration/37",
    "name": "parse_reference_path",
    "line": 351,
    "state": "covered",
    "entries": "9634"
  },
  {
    "id": "declaration/38",
    "name": "parse_type_ref",
    "line": 369,
    "state": "covered",
    "entries": "8785"
  },
  {
    "id": "declaration/39",
    "name": "parse_type_complete",
    "line": 411,
    "state": "covered",
    "entries": "11"
  },
  {
    "id": "declaration/40",
    "name": "parse_generic_parameter_tail",
    "line": 424,
    "state": "covered",
    "entries": "521"
  },
  {
    "id": "declaration/41",
    "name": "parse_generic_parameters",
    "line": 445,
    "state": "covered",
    "entries": "2460"
  },
  {
    "id": "declaration/42",
    "name": "parse_variant_payload_tail",
    "line": 460,
    "state": "covered",
    "entries": "446"
  },
  {
    "id": "declaration/43",
    "name": "parse_variant_payload",
    "line": 479,
    "state": "covered",
    "entries": "386"
  },
  {
    "id": "declaration/44",
    "name": "parse_expression_list_tail",
    "line": 494,
    "state": "covered",
    "entries": "12261"
  },
  {
    "id": "declaration/45",
    "name": "parse_expression_list",
    "line": 513,
    "state": "covered",
    "entries": "8217"
  },
  {
    "id": "declaration/46",
    "name": "parse_pattern_bindings",
    "line": 528,
    "state": "covered",
    "entries": "2729"
  },
  {
    "id": "declaration/47",
    "name": "parse_match_arm_body",
    "line": 562,
    "state": "covered",
    "entries": "1760"
  },
  {
    "id": "declaration/48",
    "name": "parse_match_arms",
    "line": 573,
    "state": "covered",
    "entries": "1769"
  },
  {
    "id": "declaration/49",
    "name": "parse_match_expression",
    "line": 630,
    "state": "covered",
    "entries": "477"
  },
  {
    "id": "declaration/50",
    "name": "parse_if_expression",
    "line": 647,
    "state": "covered",
    "entries": "1725"
  },
  {
    "id": "declaration/51",
    "name": "parse_call_type_arguments",
    "line": 669,
    "state": "covered",
    "entries": "26155"
  },
  {
    "id": "declaration/52",
    "name": "parse_named_expression",
    "line": 685,
    "state": "covered",
    "entries": "22013"
  },
  {
    "id": "declaration/53",
    "name": "parse_primary",
    "line": 701,
    "state": "covered",
    "entries": "31412"
  },
  {
    "id": "declaration/54",
    "name": "lowered_method_name",
    "line": 769,
    "state": "covered",
    "entries": "622"
  },
  {
    "id": "declaration/55",
    "name": "parse_postfix_tail",
    "line": 785,
    "state": "covered",
    "entries": "36364"
  },
  {
    "id": "declaration/56",
    "name": "parse_postfix",
    "line": 825,
    "state": "covered",
    "entries": "31412"
  },
  {
    "id": "declaration/57",
    "name": "parse_unary",
    "line": 832,
    "state": "covered",
    "entries": "31653"
  },
  {
    "id": "declaration/58",
    "name": "parse_product_tail",
    "line": 844,
    "state": "covered",
    "entries": "31381"
  },
  {
    "id": "declaration/59",
    "name": "parse_product",
    "line": 856,
    "state": "covered",
    "entries": "31302"
  },
  {
    "id": "declaration/60",
    "name": "parse_sum_tail",
    "line": 863,
    "state": "covered",
    "entries": "31271"
  },
  {
    "id": "declaration/61",
    "name": "parse_sum",
    "line": 875,
    "state": "covered",
    "entries": "30020"
  },
  {
    "id": "declaration/62",
    "name": "parse_comparison_tail",
    "line": 882,
    "state": "covered",
    "entries": "29989"
  },
  {
    "id": "declaration/63",
    "name": "parse_comparison",
    "line": 894,
    "state": "covered",
    "entries": "29264"
  },
  {
    "id": "declaration/64",
    "name": "parse_equality_tail",
    "line": 901,
    "state": "covered",
    "entries": "29233"
  },
  {
    "id": "declaration/65",
    "name": "parse_equality",
    "line": 913,
    "state": "covered",
    "entries": "27627"
  },
  {
    "id": "declaration/66",
    "name": "parse_and_tail",
    "line": 920,
    "state": "covered",
    "entries": "27596"
  },
  {
    "id": "declaration/67",
    "name": "parse_and",
    "line": 931,
    "state": "covered",
    "entries": "27113"
  },
  {
    "id": "declaration/68",
    "name": "parse_or_tail",
    "line": 938,
    "state": "covered",
    "entries": "27082"
  },
  {
    "id": "declaration/69",
    "name": "parse_or",
    "line": 949,
    "state": "covered",
    "entries": "26441"
  },
  {
    "id": "declaration/70",
    "name": "parse_range_tail",
    "line": 956,
    "state": "covered",
    "entries": "26410"
  },
  {
    "id": "declaration/71",
    "name": "parse_expression",
    "line": 967,
    "state": "covered",
    "entries": "26323"
  },
  {
    "id": "declaration/72",
    "name": "parse_complete",
    "line": 974,
    "state": "covered",
    "entries": "124"
  },
  {
    "id": "declaration/73",
    "name": "parse_while_statement",
    "line": 987,
    "state": "covered",
    "entries": "202"
  },
  {
    "id": "declaration/74",
    "name": "parse_for_statement",
    "line": 1003,
    "state": "covered",
    "entries": "436"
  },
  {
    "id": "declaration/75",
    "name": "parse_block_items",
    "line": 1029,
    "state": "covered",
    "entries": "12568"
  },
  {
    "id": "declaration/76",
    "name": "parse_block",
    "line": 1126,
    "state": "covered",
    "entries": "6460"
  },
  {
    "id": "declaration/77",
    "name": "parse_block_complete",
    "line": 1135,
    "state": "covered",
    "entries": "32"
  },
  {
    "id": "declaration/78",
    "name": "parse_type_declaration",
    "line": 1148,
    "state": "covered",
    "entries": "49"
  },
  {
    "id": "declaration/79",
    "name": "parse_record_fields",
    "line": 1186,
    "state": "covered",
    "entries": "728"
  },
  {
    "id": "declaration/80",
    "name": "parse_record_declaration",
    "line": 1229,
    "state": "covered",
    "entries": "313"
  },
  {
    "id": "declaration/81",
    "name": "parse_enum_variants",
    "line": 1249,
    "state": "covered",
    "entries": "907"
  },
  {
    "id": "declaration/82",
    "name": "parse_enum_variant_tail",
    "line": 1276,
    "state": "covered",
    "entries": "900"
  },
  {
    "id": "declaration/83",
    "name": "parse_enum_declaration",
    "line": 1295,
    "state": "covered",
    "entries": "392"
  },
  {
    "id": "declaration/84",
    "name": "parse_function_parameter_items",
    "line": 1315,
    "state": "covered",
    "entries": "1774"
  },
  {
    "id": "declaration/85",
    "name": "parse_function_parameters",
    "line": 1352,
    "state": "covered",
    "entries": "1750"
  },
  {
    "id": "declaration/86",
    "name": "parse_function_declaration",
    "line": 1362,
    "state": "covered",
    "entries": "1758"
  },
  {
    "id": "declaration/92",
    "name": "default_import_alias",
    "line": 1435,
    "state": "covered",
    "entries": "103"
  },
  {
    "id": "declaration/93",
    "name": "import_identifier",
    "line": 1447,
    "state": "covered",
    "entries": "181"
  },
  {
    "id": "declaration/94",
    "name": "parse_import_selectors",
    "line": 1452,
    "state": "covered",
    "entries": "40"
  },
  {
    "id": "declaration/95",
    "name": "parse_import_binding",
    "line": 1486,
    "state": "covered",
    "entries": "239"
  },
  {
    "id": "declaration/96",
    "name": "parse_nonimport_declaration",
    "line": 1500,
    "state": "covered",
    "entries": "2512"
  },
  {
    "id": "declaration/97",
    "name": "parse_module_items",
    "line": 1511,
    "state": "covered",
    "entries": "4983"
  },
  {
    "id": "declaration/98",
    "name": "parse_module_complete",
    "line": 1545,
    "state": "covered",
    "entries": "941"
  },
  {
    "id": "declaration/99",
    "name": "module_execution_diagnostics",
    "line": 1553,
    "state": "covered",
    "entries": "626"
  },
  {
    "id": "declaration/100",
    "name": "parse_program_complete",
    "line": 1586,
    "state": "covered",
    "entries": "494"
  },
  {
    "id": "declaration/101",
    "name": "render_expr_list",
    "line": 1596,
    "state": "covered",
    "entries": "46"
  },
  {
    "id": "declaration/102",
    "name": "render_name_list",
    "line": 1610,
    "state": "covered",
    "entries": "13"
  },
  {
    "id": "declaration/103",
    "name": "render_match_arm",
    "line": 1624,
    "state": "covered",
    "entries": "13"
  },
  {
    "id": "declaration/104",
    "name": "render_match_arms",
    "line": 1631,
    "state": "covered",
    "entries": "8"
  },
  {
    "id": "declaration/105",
    "name": "render_expr",
    "line": 1645,
    "state": "covered",
    "entries": "612"
  },
  {
    "id": "declaration/106",
    "name": "render_statement",
    "line": 1705,
    "state": "covered",
    "entries": "34"
  },
  {
    "id": "declaration/107",
    "name": "render_block",
    "line": 1734,
    "state": "covered",
    "entries": "44"
  },
  {
    "id": "declaration/108",
    "name": "render_type_parameters",
    "line": 1756,
    "state": "covered",
    "entries": "62"
  },
  {
    "id": "declaration/109",
    "name": "render_record_fields",
    "line": 1765,
    "state": "covered",
    "entries": "5"
  },
  {
    "id": "declaration/110",
    "name": "render_record_declaration",
    "line": 1781,
    "state": "covered",
    "entries": "5"
  },
  {
    "id": "declaration/111",
    "name": "render_enum_variants",
    "line": 1791,
    "state": "covered",
    "entries": "6"
  },
  {
    "id": "declaration/112",
    "name": "render_enum_declaration",
    "line": 1811,
    "state": "covered",
    "entries": "6"
  },
  {
    "id": "declaration/113",
    "name": "render_function_parameters",
    "line": 1821,
    "state": "covered",
    "entries": "8"
  },
  {
    "id": "declaration/114",
    "name": "render_function_declaration",
    "line": 1837,
    "state": "covered",
    "entries": "8"
  },
  {
    "id": "declaration/115",
    "name": "render_top_level",
    "line": 1844,
    "state": "covered",
    "entries": "32"
  },
  {
    "id": "declaration/116",
    "name": "render_program",
    "line": 1861,
    "state": "covered",
    "entries": "25"
  },
  {
    "id": "declaration/117",
    "name": "parse_source",
    "line": 1873,
    "state": "covered",
    "entries": "79"
  },
  {
    "id": "declaration/118",
    "name": "parse_block_source",
    "line": 1885,
    "state": "covered",
    "entries": "32"
  },
  {
    "id": "declaration/119",
    "name": "parse_program_source",
    "line": 1897,
    "state": "covered",
    "entries": "73"
  },
  {
    "id": "declaration/120",
    "name": "parse_type_source",
    "line": 1909,
    "state": "covered",
    "entries": "11"
  },
  {
    "id": "declaration/121",
    "name": "core_tokens",
    "line": 1922,
    "state": "covered",
    "entries": "19"
  },
  {
    "id": "declaration/122",
    "name": "lower_legacy_expressions",
    "line": 1937,
    "state": "covered",
    "entries": "7477"
  },
  {
    "id": "declaration/123",
    "name": "lower_legacy_expression",
    "line": 1943,
    "state": "covered",
    "entries": "77938"
  },
  {
    "id": "declaration/124",
    "name": "lower_legacy_block",
    "line": 1965,
    "state": "covered",
    "entries": "6053"
  },
  {
    "id": "declaration/125",
    "name": "lower_legacy_program",
    "line": 1984,
    "state": "covered",
    "entries": "498"
  },
  {
    "id": "declaration/126",
    "name": "reference_head",
    "line": 1999,
    "state": "covered",
    "entries": "8419"
  },
  {
    "id": "declaration/127",
    "name": "reference_tail",
    "line": 2005,
    "state": "covered",
    "entries": "453"
  },
  {
    "id": "declaration/128",
    "name": "expression_reference_path",
    "line": 2010,
    "state": "covered",
    "entries": "16433"
  },
  {
    "id": "declaration/129",
    "name": "type_has_qualification",
    "line": 2026,
    "state": "covered",
    "entries": "25769"
  },
  {
    "id": "declaration/130",
    "name": "expression_requires_namespaces",
    "line": 2035,
    "state": "covered",
    "entries": "150120"
  },
  {
    "id": "declaration/131",
    "name": "block_requires_namespaces",
    "line": 2072,
    "state": "covered",
    "entries": "11279"
  },
  {
    "id": "declaration/132",
    "name": "declaration_requires_namespaces",
    "line": 2096,
    "state": "covered",
    "entries": "2935"
  }
]

Source branch outcomes

[
  {
    "id": "declaration/2/statement/1/value/arm/0",
    "outcome": "LocatedExpr",
    "line": 28,
    "state": "covered",
    "hits": "5229"
  },
  {
    "id": "declaration/2/statement/1/value/arm/1",
    "outcome": "NatExpr",
    "line": 29,
    "state": "covered",
    "hits": "3562"
  },
  {
    "id": "declaration/2/statement/1/value/arm/2",
    "outcome": "DecimalExpr",
    "line": 29,
    "state": "covered",
    "hits": "16"
  },
  {
    "id": "declaration/2/statement/1/value/arm/3",
    "outcome": "StringExpr",
    "line": 29,
    "state": "covered",
    "hits": "3004"
  },
  {
    "id": "declaration/2/statement/1/value/arm/4",
    "outcome": "BoolExpr",
    "line": 29,
    "state": "covered",
    "hits": "682"
  },
  {
    "id": "declaration/2/statement/1/value/arm/5",
    "outcome": "NameExpr",
    "line": 30,
    "state": "covered",
    "hits": "17238"
  },
  {
    "id": "declaration/2/statement/1/value/arm/6",
    "outcome": "FunctionExpr",
    "line": 30,
    "state": "covered",
    "hits": "73"
  },
  {
    "id": "declaration/2/statement/1/value/arm/7",
    "outcome": "ArrayExpr",
    "line": 30,
    "state": "covered",
    "hits": "697"
  },
  {
    "id": "declaration/2/statement/1/value/arm/8",
    "outcome": "UnaryExpr",
    "line": 31,
    "state": "covered",
    "hits": "299"
  },
  {
    "id": "declaration/2/statement/1/value/arm/9",
    "outcome": "BinaryExpr",
    "line": 31,
    "state": "covered",
    "hits": "1031"
  },
  {
    "id": "declaration/2/statement/1/value/arm/10",
    "outcome": "CallExpr",
    "line": 32,
    "state": "covered",
    "hits": "7204"
  },
  {
    "id": "declaration/2/statement/1/value/arm/11",
    "outcome": "DotCallExpr",
    "line": 32,
    "state": "covered",
    "hits": "113"
  },
  {
    "id": "declaration/2/statement/1/value/arm/12",
    "outcome": "FieldExpr",
    "line": 32,
    "state": "covered",
    "hits": "372"
  },
  {
    "id": "declaration/2/statement/1/value/arm/13",
    "outcome": "IndexExpr",
    "line": 32,
    "state": "covered",
    "hits": "105"
  },
  {
    "id": "declaration/2/statement/1/value/arm/14",
    "outcome": "IfExpr",
    "line": 33,
    "state": "covered",
    "hits": "1764"
  },
  {
    "id": "declaration/2/statement/1/value/arm/15",
    "outcome": "BlockExpr",
    "line": 33,
    "state": "covered",
    "hits": "1035"
  },
  {
    "id": "declaration/2/statement/1/value/arm/16",
    "outcome": "MatchExpr",
    "line": 33,
    "state": "covered",
    "hits": "475"
  },
  {
    "id": "declaration/11/statement/6/decision/body",
    "outcome": "body",
    "line": 97,
    "state": "covered",
    "hits": "5611"
  },
  {
    "id": "declaration/11/statement/6/decision/exit",
    "outcome": "exit",
    "line": 97,
    "state": "covered",
    "hits": "1459"
  },
  {
    "id": "declaration/11/statement/6/body/statement/0/value/arm/0",
    "outcome": "ImportDeclaration",
    "line": 99,
    "state": "covered",
    "hits": "407"
  },
  {
    "id": "declaration/11/statement/6/body/statement/0/value/arm/1",
    "outcome": "TypeDeclaration",
    "line": 100,
    "state": "covered",
    "hits": "76"
  },
  {
    "id": "declaration/11/statement/6/body/statement/0/value/arm/2",
    "outcome": "RecordDeclaration",
    "line": 101,
    "state": "covered",
    "hits": "681"
  },
  {
    "id": "declaration/11/statement/6/body/statement/0/value/arm/3",
    "outcome": "EnumDeclaration",
    "line": 102,
    "state": "covered",
    "hits": "762"
  },
  {
    "id": "declaration/11/statement/6/body/statement/0/value/arm/3/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 104,
    "state": "covered",
    "hits": "1901"
  },
  {
    "id": "declaration/11/statement/6/body/statement/0/value/arm/3/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 104,
    "state": "covered",
    "hits": "762"
  },
  {
    "id": "declaration/11/statement/6/body/statement/0/value/arm/4",
    "outcome": "FunctionDeclaration",
    "line": 108,
    "state": "covered",
    "hits": "3685"
  },
  {
    "id": "declaration/24/tail/decision/true",
    "outcome": "true",
    "line": 183,
    "state": "covered",
    "hits": "45447"
  },
  {
    "id": "declaration/24/tail/decision/false",
    "outcome": "false",
    "line": 183,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/24/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 185,
    "state": "covered",
    "hits": "45447"
  },
  {
    "id": "declaration/24/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 185,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/0",
    "outcome": "LocatedExpr",
    "line": 198,
    "state": "covered",
    "hits": "12169"
  },
  {
    "id": "declaration/26/tail/arm/1",
    "outcome": "NatExpr",
    "line": 199,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/2",
    "outcome": "DecimalExpr",
    "line": 199,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/3",
    "outcome": "StringExpr",
    "line": 199,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/4",
    "outcome": "BoolExpr",
    "line": 199,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/5",
    "outcome": "NameExpr",
    "line": 200,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/6",
    "outcome": "FunctionExpr",
    "line": 200,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/7",
    "outcome": "ArrayExpr",
    "line": 200,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/8",
    "outcome": "UnaryExpr",
    "line": 201,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/9",
    "outcome": "BinaryExpr",
    "line": 201,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/26/tail/arm/10",
    "outcome": "CallExpr",
    "line": 202,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/11",
    "outcome": "DotCallExpr",
    "line": 202,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/12",
    "outcome": "FieldExpr",
    "line": 202,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/13",
    "outcome": "IndexExpr",
    "line": 202,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/14",
    "outcome": "IfExpr",
    "line": 203,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/15",
    "outcome": "BlockExpr",
    "line": 203,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/26/tail/arm/16",
    "outcome": "MatchExpr",
    "line": 203,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/27/tail/arm/0",
    "outcome": "Some",
    "line": 211,
    "state": "covered",
    "hits": "10068"
  },
  {
    "id": "declaration/27/tail/arm/1",
    "outcome": "None",
    "line": 212,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/30/statement/4/decision/body",
    "outcome": "body",
    "line": 230,
    "state": "covered",
    "hits": "1351"
  },
  {
    "id": "declaration/30/statement/4/decision/exit",
    "outcome": "exit",
    "line": 230,
    "state": "covered",
    "hits": "87"
  },
  {
    "id": "declaration/30/statement/4/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 230,
    "state": "covered",
    "hits": "1351"
  },
  {
    "id": "declaration/30/statement/4/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 230,
    "state": "covered",
    "hits": "87"
  },
  {
    "id": "declaration/30/statement/4/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 231,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/30/statement/4/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 231,
    "state": "covered",
    "hits": "1351"
  },
  {
    "id": "declaration/30/statement/4/body/statement/0/value/false/tail/decision/true",
    "outcome": "true",
    "line": 234,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/30/statement/4/body/statement/0/value/false/tail/decision/false",
    "outcome": "false",
    "line": 234,
    "state": "covered",
    "hits": "1351"
  },
  {
    "id": "declaration/30/statement/4/body/statement/0/value/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 237,
    "state": "covered",
    "hits": "87"
  },
  {
    "id": "declaration/30/statement/4/body/statement/0/value/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 237,
    "state": "covered",
    "hits": "1264"
  },
  {
    "id": "declaration/31/tail/decision/true",
    "outcome": "true",
    "line": 250,
    "state": "covered",
    "hits": "35414"
  },
  {
    "id": "declaration/31/tail/decision/false",
    "outcome": "false",
    "line": 250,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/31/tail/false/statement/1/decision/body",
    "outcome": "body",
    "line": 254,
    "state": "covered",
    "hits": "70"
  },
  {
    "id": "declaration/31/tail/false/statement/1/decision/exit",
    "outcome": "exit",
    "line": 254,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/32/tail/decision/true",
    "outcome": "true",
    "line": 262,
    "state": "covered",
    "hits": "155"
  },
  {
    "id": "declaration/32/tail/decision/false",
    "outcome": "false",
    "line": 262,
    "state": "covered",
    "hits": "154"
  },
  {
    "id": "declaration/32/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 262,
    "state": "covered",
    "hits": "308"
  },
  {
    "id": "declaration/32/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 262,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/32/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 264,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/32/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 264,
    "state": "covered",
    "hits": "154"
  },
  {
    "id": "declaration/32/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 264,
    "state": "covered",
    "hits": "155"
  },
  {
    "id": "declaration/32/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 264,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/32/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 271,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/32/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 271,
    "state": "covered",
    "hits": "151"
  },
  {
    "id": "declaration/32/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 271,
    "state": "covered",
    "hits": "153"
  },
  {
    "id": "declaration/32/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 271,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/32/tail/false/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 273,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/32/tail/false/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 273,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/32/tail/false/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 273,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/32/tail/false/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 273,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/32/tail/false/tail/true/tail/condition/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 273,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/32/tail/false/tail/true/tail/condition/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 273,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/32/tail/false/tail/true/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 276,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/32/tail/false/tail/true/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 276,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/32/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 283,
    "state": "covered",
    "hits": "151"
  },
  {
    "id": "declaration/32/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 283,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/33/tail/decision/true",
    "outcome": "true",
    "line": 293,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/33/tail/decision/false",
    "outcome": "false",
    "line": 293,
    "state": "covered",
    "hits": "242"
  },
  {
    "id": "declaration/33/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 296,
    "state": "covered",
    "hits": "87"
  },
  {
    "id": "declaration/33/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 296,
    "state": "covered",
    "hits": "155"
  },
  {
    "id": "declaration/33/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 299,
    "state": "covered",
    "hits": "155"
  },
  {
    "id": "declaration/33/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 299,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/34/statement/2/decision/body",
    "outcome": "body",
    "line": 311,
    "state": "covered",
    "hits": "977"
  },
  {
    "id": "declaration/34/statement/2/decision/exit",
    "outcome": "exit",
    "line": 311,
    "state": "covered",
    "hits": "620"
  },
  {
    "id": "declaration/34/statement/2/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 312,
    "state": "covered",
    "hits": "620"
  },
  {
    "id": "declaration/34/statement/2/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 312,
    "state": "covered",
    "hits": "357"
  },
  {
    "id": "declaration/35/tail/decision/true",
    "outcome": "true",
    "line": 323,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/35/tail/decision/false",
    "outcome": "false",
    "line": 323,
    "state": "covered",
    "hits": "1009"
  },
  {
    "id": "declaration/35/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 326,
    "state": "covered",
    "hits": "652"
  },
  {
    "id": "declaration/35/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 326,
    "state": "covered",
    "hits": "357"
  },
  {
    "id": "declaration/35/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 329,
    "state": "covered",
    "hits": "356"
  },
  {
    "id": "declaration/35/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 329,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/35/tail/false/tail/false/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 331,
    "state": "covered",
    "hits": "355"
  },
  {
    "id": "declaration/35/tail/false/tail/false/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 332,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/36/tail/arm/0",
    "outcome": "Ok",
    "line": 343,
    "state": "covered",
    "hits": "654"
  },
  {
    "id": "declaration/36/tail/arm/1",
    "outcome": "Error",
    "line": 347,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/37/tail/decision/true",
    "outcome": "true",
    "line": 352,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/37/tail/decision/false",
    "outcome": "false",
    "line": 352,
    "state": "covered",
    "hits": "9634"
  },
  {
    "id": "declaration/37/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 352,
    "state": "covered",
    "hits": "9634"
  },
  {
    "id": "declaration/37/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 352,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/37/tail/false/statement/3/decision/body",
    "outcome": "body",
    "line": 358,
    "state": "covered",
    "hits": "76"
  },
  {
    "id": "declaration/37/tail/false/statement/3/decision/exit",
    "outcome": "exit",
    "line": 358,
    "state": "covered",
    "hits": "9634"
  },
  {
    "id": "declaration/37/tail/false/statement/3/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 358,
    "state": "covered",
    "hits": "76"
  },
  {
    "id": "declaration/37/tail/false/statement/3/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 358,
    "state": "covered",
    "hits": "9634"
  },
  {
    "id": "declaration/37/tail/false/statement/3/condition/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 358,
    "state": "covered",
    "hits": "9655"
  },
  {
    "id": "declaration/37/tail/false/statement/3/condition/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 358,
    "state": "covered",
    "hits": "55"
  },
  {
    "id": "declaration/37/tail/false/statement/3/body/tail/decision/true",
    "outcome": "true",
    "line": 359,
    "state": "covered",
    "hits": "76"
  },
  {
    "id": "declaration/37/tail/false/statement/3/body/tail/decision/false",
    "outcome": "false",
    "line": 359,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/37/tail/false/statement/3/body/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 359,
    "state": "covered",
    "hits": "76"
  },
  {
    "id": "declaration/37/tail/false/statement/3/body/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 359,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/37/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 364,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/37/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 364,
    "state": "covered",
    "hits": "9634"
  },
  {
    "id": "declaration/38/tail/decision/true",
    "outcome": "true",
    "line": 370,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/38/tail/decision/false",
    "outcome": "false",
    "line": 370,
    "state": "covered",
    "hits": "8784"
  },
  {
    "id": "declaration/38/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 373,
    "state": "covered",
    "hits": "1035"
  },
  {
    "id": "declaration/38/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 373,
    "state": "covered",
    "hits": "7749"
  },
  {
    "id": "declaration/38/tail/false/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 375,
    "state": "covered",
    "hits": "1034"
  },
  {
    "id": "declaration/38/tail/false/tail/true/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 376,
    "state": "covered",
    "hits": "1033"
  },
  {
    "id": "declaration/38/tail/false/tail/true/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 376,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/38/tail/false/tail/true/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 376,
    "state": "covered",
    "hits": "1033"
  },
  {
    "id": "declaration/38/tail/false/tail/true/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 376,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/38/tail/false/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 383,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 386,
    "state": "covered",
    "hits": "7739"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 386,
    "state": "covered",
    "hits": "10"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/true/tail/arm/0",
    "outcome": "Error",
    "line": 388,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/true/tail/arm/1",
    "outcome": "Ok",
    "line": 389,
    "state": "covered",
    "hits": "7739"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/true/tail/arm/1/body/block/tail/decision/true",
    "outcome": "true",
    "line": 391,
    "state": "covered",
    "hits": "608"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/true/tail/arm/1/body/block/tail/decision/false",
    "outcome": "false",
    "line": 391,
    "state": "covered",
    "hits": "7131"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/true/tail/arm/1/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 391,
    "state": "covered",
    "hits": "7734"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/true/tail/arm/1/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 391,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/true/tail/arm/1/body/block/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 393,
    "state": "covered",
    "hits": "604"
  },
  {
    "id": "declaration/38/tail/false/tail/false/tail/true/tail/arm/1/body/block/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 397,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/39/tail/arm/0",
    "outcome": "Ok",
    "line": 413,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/39/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 414,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/39/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 414,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/39/tail/arm/1",
    "outcome": "Error",
    "line": 420,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/40/tail/decision/true",
    "outcome": "true",
    "line": 425,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/40/tail/decision/false",
    "outcome": "false",
    "line": 425,
    "state": "covered",
    "hits": "521"
  },
  {
    "id": "declaration/40/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 428,
    "state": "covered",
    "hits": "429"
  },
  {
    "id": "declaration/40/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 428,
    "state": "covered",
    "hits": "92"
  },
  {
    "id": "declaration/40/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 431,
    "state": "covered",
    "hits": "89"
  },
  {
    "id": "declaration/40/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 431,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/40/tail/false/tail/false/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 433,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/40/tail/false/tail/false/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 433,
    "state": "covered",
    "hits": "87"
  },
  {
    "id": "declaration/40/tail/false/tail/false/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 433,
    "state": "covered",
    "hits": "89"
  },
  {
    "id": "declaration/40/tail/false/tail/false/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 433,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/41/tail/decision/true",
    "outcome": "true",
    "line": 446,
    "state": "covered",
    "hits": "2024"
  },
  {
    "id": "declaration/41/tail/decision/false",
    "outcome": "false",
    "line": 446,
    "state": "covered",
    "hits": "436"
  },
  {
    "id": "declaration/41/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 446,
    "state": "covered",
    "hits": "2454"
  },
  {
    "id": "declaration/41/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 446,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/41/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 451,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/41/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 451,
    "state": "covered",
    "hits": "434"
  },
  {
    "id": "declaration/41/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 451,
    "state": "covered",
    "hits": "436"
  },
  {
    "id": "declaration/41/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 451,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/42/tail/decision/true",
    "outcome": "true",
    "line": 461,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/42/tail/decision/false",
    "outcome": "false",
    "line": 461,
    "state": "covered",
    "hits": "446"
  },
  {
    "id": "declaration/42/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 464,
    "state": "covered",
    "hits": "382"
  },
  {
    "id": "declaration/42/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 464,
    "state": "covered",
    "hits": "64"
  },
  {
    "id": "declaration/42/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 467,
    "state": "covered",
    "hits": "62"
  },
  {
    "id": "declaration/42/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 467,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/42/tail/false/tail/false/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 469,
    "state": "covered",
    "hits": "61"
  },
  {
    "id": "declaration/42/tail/false/tail/false/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 470,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/43/tail/decision/true",
    "outcome": "true",
    "line": 480,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/43/tail/decision/false",
    "outcome": "false",
    "line": 480,
    "state": "covered",
    "hits": "386"
  },
  {
    "id": "declaration/43/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 480,
    "state": "covered",
    "hits": "386"
  },
  {
    "id": "declaration/43/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 480,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/43/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 485,
    "state": "covered",
    "hits": "385"
  },
  {
    "id": "declaration/43/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 489,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/44/tail/decision/true",
    "outcome": "true",
    "line": 495,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/44/tail/decision/false",
    "outcome": "false",
    "line": 495,
    "state": "covered",
    "hits": "12261"
  },
  {
    "id": "declaration/44/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 498,
    "state": "covered",
    "hits": "6797"
  },
  {
    "id": "declaration/44/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 498,
    "state": "covered",
    "hits": "5464"
  },
  {
    "id": "declaration/44/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 501,
    "state": "covered",
    "hits": "5462"
  },
  {
    "id": "declaration/44/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 501,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/44/tail/false/tail/false/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 503,
    "state": "covered",
    "hits": "5461"
  },
  {
    "id": "declaration/44/tail/false/tail/false/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 504,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/45/tail/decision/true",
    "outcome": "true",
    "line": 514,
    "state": "covered",
    "hits": "1417"
  },
  {
    "id": "declaration/45/tail/decision/false",
    "outcome": "false",
    "line": 514,
    "state": "covered",
    "hits": "6800"
  },
  {
    "id": "declaration/45/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 514,
    "state": "covered",
    "hits": "8217"
  },
  {
    "id": "declaration/45/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 514,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/45/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 519,
    "state": "covered",
    "hits": "6800"
  },
  {
    "id": "declaration/45/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 523,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/46/tail/decision/true",
    "outcome": "true",
    "line": 529,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/46/tail/decision/false",
    "outcome": "false",
    "line": 529,
    "state": "covered",
    "hits": "2729"
  },
  {
    "id": "declaration/46/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 532,
    "state": "covered",
    "hits": "249"
  },
  {
    "id": "declaration/46/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 532,
    "state": "covered",
    "hits": "2480"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 535,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 535,
    "state": "covered",
    "hits": "2479"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 540,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 540,
    "state": "covered",
    "hits": "2479"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 543,
    "state": "covered",
    "hits": "1512"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 543,
    "state": "covered",
    "hits": "967"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 546,
    "state": "covered",
    "hits": "966"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 546,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 547,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 547,
    "state": "covered",
    "hits": "965"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 547,
    "state": "covered",
    "hits": "966"
  },
  {
    "id": "declaration/46/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 547,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/47/tail/decision/true",
    "outcome": "true",
    "line": 563,
    "state": "covered",
    "hits": "1018"
  },
  {
    "id": "declaration/47/tail/decision/false",
    "outcome": "false",
    "line": 563,
    "state": "covered",
    "hits": "742"
  },
  {
    "id": "declaration/47/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 563,
    "state": "covered",
    "hits": "1760"
  },
  {
    "id": "declaration/47/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 563,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/47/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 565,
    "state": "covered",
    "hits": "1018"
  },
  {
    "id": "declaration/47/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 566,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/48/tail/decision/true",
    "outcome": "true",
    "line": 574,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/48/tail/decision/false",
    "outcome": "false",
    "line": 574,
    "state": "covered",
    "hits": "1768"
  },
  {
    "id": "declaration/48/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 577,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/48/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 577,
    "state": "covered",
    "hits": "1766"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 580,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 580,
    "state": "covered",
    "hits": "1765"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/0",
    "outcome": "Error",
    "line": 584,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1",
    "outcome": "Ok",
    "line": 585,
    "state": "covered",
    "hits": "1765"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/decision/true",
    "outcome": "true",
    "line": 588,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/decision/false",
    "outcome": "false",
    "line": 588,
    "state": "covered",
    "hits": "1764"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 588,
    "state": "covered",
    "hits": "1765"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 588,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 593,
    "state": "covered",
    "hits": "1761"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 594,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 594,
    "state": "covered",
    "hits": "1760"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 594,
    "state": "covered",
    "hits": "1761"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 594,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 598,
    "state": "covered",
    "hits": "1759"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 602,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 602,
    "state": "covered",
    "hits": "1759"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 605,
    "state": "covered",
    "hits": "1294"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 605,
    "state": "covered",
    "hits": "465"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 608,
    "state": "covered",
    "hits": "464"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 608,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 616,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/48/tail/false/tail/false/tail/false/tail/arm/1/body/block/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 620,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/49/tail/arm/0",
    "outcome": "Ok",
    "line": 632,
    "state": "covered",
    "hits": "476"
  },
  {
    "id": "declaration/49/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 633,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/49/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 633,
    "state": "covered",
    "hits": "475"
  },
  {
    "id": "declaration/49/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 633,
    "state": "covered",
    "hits": "475"
  },
  {
    "id": "declaration/49/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 633,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/49/tail/arm/0/body/block/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 638,
    "state": "covered",
    "hits": "466"
  },
  {
    "id": "declaration/49/tail/arm/0/body/block/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 639,
    "state": "covered",
    "hits": "9"
  },
  {
    "id": "declaration/49/tail/arm/1",
    "outcome": "Error",
    "line": 643,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/50/tail/arm/0",
    "outcome": "Ok",
    "line": 649,
    "state": "covered",
    "hits": "1724"
  },
  {
    "id": "declaration/50/tail/arm/0/body/block/tail/arm/0",
    "outcome": "Ok",
    "line": 651,
    "state": "covered",
    "hits": "1723"
  },
  {
    "id": "declaration/50/tail/arm/0/body/block/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 652,
    "state": "covered",
    "hits": "1313"
  },
  {
    "id": "declaration/50/tail/arm/0/body/block/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 652,
    "state": "covered",
    "hits": "410"
  },
  {
    "id": "declaration/50/tail/arm/0/body/block/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 652,
    "state": "covered",
    "hits": "1720"
  },
  {
    "id": "declaration/50/tail/arm/0/body/block/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 652,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/50/tail/arm/0/body/block/tail/arm/0/body/block/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 654,
    "state": "covered",
    "hits": "1311"
  },
  {
    "id": "declaration/50/tail/arm/0/body/block/tail/arm/0/body/block/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 655,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/50/tail/arm/0/body/block/tail/arm/1",
    "outcome": "Error",
    "line": 662,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/50/tail/arm/1",
    "outcome": "Error",
    "line": 665,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/51/statement/2/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 672,
    "state": "covered",
    "hits": "26135"
  },
  {
    "id": "declaration/51/statement/2/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 672,
    "state": "covered",
    "hits": "20"
  },
  {
    "id": "declaration/51/statement/3/decision/body",
    "outcome": "body",
    "line": 673,
    "state": "covered",
    "hits": "2821"
  },
  {
    "id": "declaration/51/statement/3/decision/exit",
    "outcome": "exit",
    "line": 673,
    "state": "covered",
    "hits": "26155"
  },
  {
    "id": "declaration/51/statement/3/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 673,
    "state": "covered",
    "hits": "2822"
  },
  {
    "id": "declaration/51/statement/3/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 673,
    "state": "covered",
    "hits": "26154"
  },
  {
    "id": "declaration/51/statement/3/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 674,
    "state": "covered",
    "hits": "886"
  },
  {
    "id": "declaration/51/statement/3/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 674,
    "state": "covered",
    "hits": "1935"
  },
  {
    "id": "declaration/51/statement/3/body/statement/1/value/decision/true",
    "outcome": "true",
    "line": 675,
    "state": "covered",
    "hits": "885"
  },
  {
    "id": "declaration/51/statement/3/body/statement/1/value/decision/false",
    "outcome": "false",
    "line": 675,
    "state": "covered",
    "hits": "1936"
  },
  {
    "id": "declaration/51/statement/3/body/statement/1/value/true/tail/decision/true",
    "outcome": "true",
    "line": 675,
    "state": "covered",
    "hits": "878"
  },
  {
    "id": "declaration/51/statement/3/body/statement/1/value/true/tail/decision/false",
    "outcome": "false",
    "line": 675,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/51/statement/3/body/tail/decision/true",
    "outcome": "true",
    "line": 676,
    "state": "covered",
    "hits": "1943"
  },
  {
    "id": "declaration/51/statement/3/body/tail/decision/false",
    "outcome": "false",
    "line": 676,
    "state": "covered",
    "hits": "878"
  },
  {
    "id": "declaration/51/tail/decision/true",
    "outcome": "true",
    "line": 678,
    "state": "covered",
    "hits": "48"
  },
  {
    "id": "declaration/51/tail/decision/false",
    "outcome": "false",
    "line": 678,
    "state": "covered",
    "hits": "26107"
  },
  {
    "id": "declaration/51/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 678,
    "state": "covered",
    "hits": "872"
  },
  {
    "id": "declaration/51/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 678,
    "state": "covered",
    "hits": "25283"
  },
  {
    "id": "declaration/51/tail/condition/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 678,
    "state": "covered",
    "hits": "879"
  },
  {
    "id": "declaration/51/tail/condition/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 678,
    "state": "covered",
    "hits": "25276"
  },
  {
    "id": "declaration/52/tail/arm/0",
    "outcome": "Error",
    "line": 687,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/52/tail/arm/1",
    "outcome": "Ok",
    "line": 688,
    "state": "covered",
    "hits": "22013"
  },
  {
    "id": "declaration/52/tail/arm/1/body/block/tail/decision/true",
    "outcome": "true",
    "line": 689,
    "state": "covered",
    "hits": "6580"
  },
  {
    "id": "declaration/52/tail/arm/1/body/block/tail/decision/false",
    "outcome": "false",
    "line": 689,
    "state": "covered",
    "hits": "15433"
  },
  {
    "id": "declaration/52/tail/arm/1/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 689,
    "state": "covered",
    "hits": "21995"
  },
  {
    "id": "declaration/52/tail/arm/1/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 689,
    "state": "covered",
    "hits": "18"
  },
  {
    "id": "declaration/52/tail/arm/1/body/block/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 691,
    "state": "covered",
    "hits": "6579"
  },
  {
    "id": "declaration/52/tail/arm/1/body/block/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 692,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/53/tail/decision/true",
    "outcome": "true",
    "line": 702,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/53/tail/decision/false",
    "outcome": "false",
    "line": 702,
    "state": "covered",
    "hits": "31407"
  },
  {
    "id": "declaration/53/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 706,
    "state": "covered",
    "hits": "72"
  },
  {
    "id": "declaration/53/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 706,
    "state": "covered",
    "hits": "31335"
  },
  {
    "id": "declaration/53/tail/false/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 707,
    "state": "covered",
    "hits": "72"
  },
  {
    "id": "declaration/53/tail/false/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 707,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/53/tail/false/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 707,
    "state": "covered",
    "hits": "72"
  },
  {
    "id": "declaration/53/tail/false/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 707,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/53/tail/false/tail/true/tail/true/tail/arm/0",
    "outcome": "Error",
    "line": 709,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/53/tail/false/tail/true/tail/true/tail/arm/1",
    "outcome": "Ok",
    "line": 710,
    "state": "covered",
    "hits": "72"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 715,
    "state": "covered",
    "hits": "477"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 715,
    "state": "covered",
    "hits": "30858"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 718,
    "state": "covered",
    "hits": "1725"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 718,
    "state": "covered",
    "hits": "29133"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 721,
    "state": "covered",
    "hits": "2983"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 721,
    "state": "covered",
    "hits": "26150"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 724,
    "state": "covered",
    "hits": "16"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 724,
    "state": "covered",
    "hits": "26134"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 727,
    "state": "covered",
    "hits": "2580"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 727,
    "state": "covered",
    "hits": "23554"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 730,
    "state": "covered",
    "hits": "631"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 730,
    "state": "covered",
    "hits": "22923"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 730,
    "state": "covered",
    "hits": "23275"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 730,
    "state": "covered",
    "hits": "279"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 733,
    "state": "covered",
    "hits": "22013"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 733,
    "state": "covered",
    "hits": "910"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 736,
    "state": "covered",
    "hits": "237"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 736,
    "state": "covered",
    "hits": "673"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 737,
    "state": "covered",
    "hits": "33"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 737,
    "state": "covered",
    "hits": "204"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 737,
    "state": "covered",
    "hits": "237"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 737,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 740,
    "state": "covered",
    "hits": "204"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 741,
    "state": "covered",
    "hits": "203"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 741,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/false/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 741,
    "state": "covered",
    "hits": "203"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/false/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 741,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 747,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 750,
    "state": "covered",
    "hits": "668"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 750,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 752,
    "state": "covered",
    "hits": "667"
  },
  {
    "id": "declaration/53/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 753,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/54/statement/1/value/decision/true",
    "outcome": "true",
    "line": 771,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/54/statement/1/value/decision/false",
    "outcome": "false",
    "line": 771,
    "state": "covered",
    "hits": "620"
  },
  {
    "id": "declaration/54/statement/2/value/decision/true",
    "outcome": "true",
    "line": 772,
    "state": "covered",
    "hits": "16"
  },
  {
    "id": "declaration/54/statement/2/value/decision/false",
    "outcome": "false",
    "line": 772,
    "state": "covered",
    "hits": "606"
  },
  {
    "id": "declaration/54/statement/3/value/decision/true",
    "outcome": "true",
    "line": 773,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/54/statement/3/value/decision/false",
    "outcome": "false",
    "line": 773,
    "state": "covered",
    "hits": "619"
  },
  {
    "id": "declaration/54/statement/4/value/decision/true",
    "outcome": "true",
    "line": 774,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/54/statement/4/value/decision/false",
    "outcome": "false",
    "line": 774,
    "state": "covered",
    "hits": "621"
  },
  {
    "id": "declaration/54/statement/5/value/decision/true",
    "outcome": "true",
    "line": 775,
    "state": "covered",
    "hits": "27"
  },
  {
    "id": "declaration/54/statement/5/value/decision/false",
    "outcome": "false",
    "line": 775,
    "state": "covered",
    "hits": "595"
  },
  {
    "id": "declaration/54/statement/6/value/decision/true",
    "outcome": "true",
    "line": 776,
    "state": "covered",
    "hits": "69"
  },
  {
    "id": "declaration/54/statement/6/value/decision/false",
    "outcome": "false",
    "line": 776,
    "state": "covered",
    "hits": "553"
  },
  {
    "id": "declaration/54/statement/7/value/decision/true",
    "outcome": "true",
    "line": 777,
    "state": "covered",
    "hits": "34"
  },
  {
    "id": "declaration/54/statement/7/value/decision/false",
    "outcome": "false",
    "line": 777,
    "state": "covered",
    "hits": "588"
  },
  {
    "id": "declaration/54/statement/8/value/decision/true",
    "outcome": "true",
    "line": 778,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/54/statement/8/value/decision/false",
    "outcome": "false",
    "line": 778,
    "state": "covered",
    "hits": "591"
  },
  {
    "id": "declaration/54/statement/9/value/decision/true",
    "outcome": "true",
    "line": 779,
    "state": "covered",
    "hits": "51"
  },
  {
    "id": "declaration/54/statement/9/value/decision/false",
    "outcome": "false",
    "line": 779,
    "state": "covered",
    "hits": "571"
  },
  {
    "id": "declaration/54/statement/10/value/decision/true",
    "outcome": "true",
    "line": 780,
    "state": "covered",
    "hits": "20"
  },
  {
    "id": "declaration/54/statement/10/value/decision/false",
    "outcome": "false",
    "line": 780,
    "state": "covered",
    "hits": "602"
  },
  {
    "id": "declaration/54/statement/11/value/decision/true",
    "outcome": "true",
    "line": 781,
    "state": "covered",
    "hits": "14"
  },
  {
    "id": "declaration/54/statement/11/value/decision/false",
    "outcome": "false",
    "line": 781,
    "state": "covered",
    "hits": "608"
  },
  {
    "id": "declaration/55/tail/decision/true",
    "outcome": "true",
    "line": 786,
    "state": "covered",
    "hits": "840"
  },
  {
    "id": "declaration/55/tail/decision/false",
    "outcome": "false",
    "line": 786,
    "state": "covered",
    "hits": "35524"
  },
  {
    "id": "declaration/55/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 786,
    "state": "covered",
    "hits": "36250"
  },
  {
    "id": "declaration/55/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 786,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/55/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 788,
    "state": "covered",
    "hits": "840"
  },
  {
    "id": "declaration/55/tail/true/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 789,
    "state": "covered",
    "hits": "839"
  },
  {
    "id": "declaration/55/tail/true/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 789,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/55/tail/true/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 789,
    "state": "covered",
    "hits": "839"
  },
  {
    "id": "declaration/55/tail/true/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 789,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/55/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 795,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/55/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 798,
    "state": "covered",
    "hits": "4143"
  },
  {
    "id": "declaration/55/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 798,
    "state": "covered",
    "hits": "31381"
  },
  {
    "id": "declaration/55/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 798,
    "state": "covered",
    "hits": "35410"
  },
  {
    "id": "declaration/55/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 798,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 799,
    "state": "covered",
    "hits": "4142"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 799,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 799,
    "state": "covered",
    "hits": "4142"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 799,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/true/tail/arm/0",
    "outcome": "Error",
    "line": 802,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/true/tail/arm/1",
    "outcome": "Ok",
    "line": 803,
    "state": "covered",
    "hits": "4142"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/true/tail/arm/1/body/block/tail/decision/true",
    "outcome": "true",
    "line": 804,
    "state": "covered",
    "hits": "969"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/true/tail/arm/1/body/block/tail/decision/false",
    "outcome": "false",
    "line": 804,
    "state": "covered",
    "hits": "3173"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/true/tail/arm/1/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 804,
    "state": "covered",
    "hits": "4140"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/true/tail/arm/1/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 804,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/true/tail/arm/1/body/block/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 806,
    "state": "covered",
    "hits": "968"
  },
  {
    "id": "declaration/55/tail/false/tail/true/tail/true/tail/arm/1/body/block/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 809,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/56/tail/arm/0",
    "outcome": "Ok",
    "line": 827,
    "state": "covered",
    "hits": "31384"
  },
  {
    "id": "declaration/56/tail/arm/1",
    "outcome": "Error",
    "line": 828,
    "state": "covered",
    "hits": "28"
  },
  {
    "id": "declaration/57/tail/decision/true",
    "outcome": "true",
    "line": 833,
    "state": "covered",
    "hits": "241"
  },
  {
    "id": "declaration/57/tail/decision/false",
    "outcome": "false",
    "line": 833,
    "state": "covered",
    "hits": "31412"
  },
  {
    "id": "declaration/57/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 833,
    "state": "covered",
    "hits": "31648"
  },
  {
    "id": "declaration/57/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 833,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/57/tail/condition/right/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 833,
    "state": "covered",
    "hits": "31437"
  },
  {
    "id": "declaration/57/tail/condition/right/decision/skip-right",
    "outcome": "skip-right",
    "line": 833,
    "state": "covered",
    "hits": "211"
  },
  {
    "id": "declaration/57/tail/condition/right/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 833,
    "state": "covered",
    "hits": "31621"
  },
  {
    "id": "declaration/57/tail/condition/right/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 833,
    "state": "covered",
    "hits": "27"
  },
  {
    "id": "declaration/57/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 836,
    "state": "covered",
    "hits": "241"
  },
  {
    "id": "declaration/57/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 837,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/58/tail/decision/true",
    "outcome": "true",
    "line": 845,
    "state": "covered",
    "hits": "110"
  },
  {
    "id": "declaration/58/tail/decision/false",
    "outcome": "false",
    "line": 845,
    "state": "covered",
    "hits": "31271"
  },
  {
    "id": "declaration/58/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 845,
    "state": "covered",
    "hits": "31267"
  },
  {
    "id": "declaration/58/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 845,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/58/tail/condition/right/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 845,
    "state": "covered",
    "hits": "31173"
  },
  {
    "id": "declaration/58/tail/condition/right/decision/skip-right",
    "outcome": "skip-right",
    "line": 845,
    "state": "covered",
    "hits": "94"
  },
  {
    "id": "declaration/58/tail/condition/right/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 845,
    "state": "covered",
    "hits": "31231"
  },
  {
    "id": "declaration/58/tail/condition/right/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 845,
    "state": "covered",
    "hits": "36"
  },
  {
    "id": "declaration/58/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 848,
    "state": "covered",
    "hits": "110"
  },
  {
    "id": "declaration/58/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 849,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/59/tail/arm/0",
    "outcome": "Ok",
    "line": 858,
    "state": "covered",
    "hits": "31271"
  },
  {
    "id": "declaration/59/tail/arm/1",
    "outcome": "Error",
    "line": 859,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/60/tail/decision/true",
    "outcome": "true",
    "line": 864,
    "state": "covered",
    "hits": "1282"
  },
  {
    "id": "declaration/60/tail/decision/false",
    "outcome": "false",
    "line": 864,
    "state": "covered",
    "hits": "29989"
  },
  {
    "id": "declaration/60/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 864,
    "state": "covered",
    "hits": "31157"
  },
  {
    "id": "declaration/60/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 864,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/60/tail/condition/right/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 864,
    "state": "covered",
    "hits": "30026"
  },
  {
    "id": "declaration/60/tail/condition/right/decision/skip-right",
    "outcome": "skip-right",
    "line": 864,
    "state": "covered",
    "hits": "1131"
  },
  {
    "id": "declaration/60/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 867,
    "state": "covered",
    "hits": "1281"
  },
  {
    "id": "declaration/60/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 868,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/61/tail/arm/0",
    "outcome": "Ok",
    "line": 877,
    "state": "covered",
    "hits": "29990"
  },
  {
    "id": "declaration/61/tail/arm/1",
    "outcome": "Error",
    "line": 878,
    "state": "covered",
    "hits": "30"
  },
  {
    "id": "declaration/62/tail/decision/true",
    "outcome": "true",
    "line": 883,
    "state": "covered",
    "hits": "756"
  },
  {
    "id": "declaration/62/tail/decision/false",
    "outcome": "false",
    "line": 883,
    "state": "covered",
    "hits": "29233"
  },
  {
    "id": "declaration/62/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 883,
    "state": "covered",
    "hits": "29875"
  },
  {
    "id": "declaration/62/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 883,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/62/tail/condition/right/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 883,
    "state": "covered",
    "hits": "29268"
  },
  {
    "id": "declaration/62/tail/condition/right/decision/skip-right",
    "outcome": "skip-right",
    "line": 883,
    "state": "covered",
    "hits": "607"
  },
  {
    "id": "declaration/62/tail/condition/right/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 883,
    "state": "covered",
    "hits": "29439"
  },
  {
    "id": "declaration/62/tail/condition/right/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 883,
    "state": "covered",
    "hits": "436"
  },
  {
    "id": "declaration/62/tail/condition/right/left/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 883,
    "state": "covered",
    "hits": "29495"
  },
  {
    "id": "declaration/62/tail/condition/right/left/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 883,
    "state": "covered",
    "hits": "380"
  },
  {
    "id": "declaration/62/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 886,
    "state": "covered",
    "hits": "756"
  },
  {
    "id": "declaration/62/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 887,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/63/tail/arm/0",
    "outcome": "Ok",
    "line": 896,
    "state": "covered",
    "hits": "29233"
  },
  {
    "id": "declaration/63/tail/arm/1",
    "outcome": "Error",
    "line": 897,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/64/tail/decision/true",
    "outcome": "true",
    "line": 902,
    "state": "covered",
    "hits": "1637"
  },
  {
    "id": "declaration/64/tail/decision/false",
    "outcome": "false",
    "line": 902,
    "state": "covered",
    "hits": "27596"
  },
  {
    "id": "declaration/64/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 902,
    "state": "covered",
    "hits": "29119"
  },
  {
    "id": "declaration/64/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 902,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/64/tail/condition/right/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 902,
    "state": "covered",
    "hits": "27648"
  },
  {
    "id": "declaration/64/tail/condition/right/decision/skip-right",
    "outcome": "skip-right",
    "line": 902,
    "state": "covered",
    "hits": "1471"
  },
  {
    "id": "declaration/64/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 905,
    "state": "covered",
    "hits": "1637"
  },
  {
    "id": "declaration/64/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 906,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/65/tail/arm/0",
    "outcome": "Ok",
    "line": 915,
    "state": "covered",
    "hits": "27596"
  },
  {
    "id": "declaration/65/tail/arm/1",
    "outcome": "Error",
    "line": 916,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/66/tail/decision/true",
    "outcome": "true",
    "line": 921,
    "state": "covered",
    "hits": "514"
  },
  {
    "id": "declaration/66/tail/decision/false",
    "outcome": "false",
    "line": 921,
    "state": "covered",
    "hits": "27082"
  },
  {
    "id": "declaration/66/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 921,
    "state": "covered",
    "hits": "27482"
  },
  {
    "id": "declaration/66/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 921,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/66/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 923,
    "state": "covered",
    "hits": "514"
  },
  {
    "id": "declaration/66/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 924,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/67/tail/arm/0",
    "outcome": "Ok",
    "line": 933,
    "state": "covered",
    "hits": "27082"
  },
  {
    "id": "declaration/67/tail/arm/1",
    "outcome": "Error",
    "line": 934,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/68/tail/decision/true",
    "outcome": "true",
    "line": 939,
    "state": "covered",
    "hits": "672"
  },
  {
    "id": "declaration/68/tail/decision/false",
    "outcome": "false",
    "line": 939,
    "state": "covered",
    "hits": "26410"
  },
  {
    "id": "declaration/68/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 939,
    "state": "covered",
    "hits": "26968"
  },
  {
    "id": "declaration/68/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 939,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/68/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 941,
    "state": "covered",
    "hits": "672"
  },
  {
    "id": "declaration/68/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 942,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/69/tail/arm/0",
    "outcome": "Ok",
    "line": 951,
    "state": "covered",
    "hits": "26410"
  },
  {
    "id": "declaration/69/tail/arm/1",
    "outcome": "Error",
    "line": 952,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/70/tail/decision/true",
    "outcome": "true",
    "line": 957,
    "state": "covered",
    "hits": "118"
  },
  {
    "id": "declaration/70/tail/decision/false",
    "outcome": "false",
    "line": 957,
    "state": "covered",
    "hits": "26292"
  },
  {
    "id": "declaration/70/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 957,
    "state": "covered",
    "hits": "26296"
  },
  {
    "id": "declaration/70/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 957,
    "state": "covered",
    "hits": "114"
  },
  {
    "id": "declaration/70/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 959,
    "state": "covered",
    "hits": "118"
  },
  {
    "id": "declaration/70/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 960,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/71/tail/arm/0",
    "outcome": "Ok",
    "line": 969,
    "state": "covered",
    "hits": "26292"
  },
  {
    "id": "declaration/71/tail/arm/1",
    "outcome": "Error",
    "line": 970,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/72/tail/arm/0",
    "outcome": "Ok",
    "line": 976,
    "state": "covered",
    "hits": "100"
  },
  {
    "id": "declaration/72/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 977,
    "state": "covered",
    "hits": "99"
  },
  {
    "id": "declaration/72/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 977,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/72/tail/arm/1",
    "outcome": "Error",
    "line": 983,
    "state": "covered",
    "hits": "24"
  },
  {
    "id": "declaration/73/tail/arm/0",
    "outcome": "Ok",
    "line": 989,
    "state": "covered",
    "hits": "201"
  },
  {
    "id": "declaration/73/tail/arm/0/body/block/tail/arm/0",
    "outcome": "Ok",
    "line": 991,
    "state": "covered",
    "hits": "200"
  },
  {
    "id": "declaration/73/tail/arm/0/body/block/tail/arm/0/body/block/statement/0/value/decision/true",
    "outcome": "true",
    "line": 992,
    "state": "covered",
    "hits": "185"
  },
  {
    "id": "declaration/73/tail/arm/0/body/block/tail/arm/0/body/block/statement/0/value/decision/false",
    "outcome": "false",
    "line": 992,
    "state": "covered",
    "hits": "15"
  },
  {
    "id": "declaration/73/tail/arm/0/body/block/tail/arm/0/body/block/statement/0/value/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 992,
    "state": "covered",
    "hits": "200"
  },
  {
    "id": "declaration/73/tail/arm/0/body/block/tail/arm/0/body/block/statement/0/value/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 992,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/73/tail/arm/0/body/block/tail/arm/1",
    "outcome": "Error",
    "line": 996,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/73/tail/arm/1",
    "outcome": "Error",
    "line": 999,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/74/tail/decision/true",
    "outcome": "true",
    "line": 1005,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/74/tail/decision/false",
    "outcome": "false",
    "line": 1005,
    "state": "covered",
    "hits": "435"
  },
  {
    "id": "declaration/74/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1005,
    "state": "covered",
    "hits": "436"
  },
  {
    "id": "declaration/74/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1005,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/74/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1009,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/74/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1009,
    "state": "covered",
    "hits": "433"
  },
  {
    "id": "declaration/74/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1009,
    "state": "covered",
    "hits": "435"
  },
  {
    "id": "declaration/74/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1009,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/74/tail/false/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1013,
    "state": "covered",
    "hits": "432"
  },
  {
    "id": "declaration/74/tail/false/tail/false/tail/arm/0/body/block/tail/arm/0",
    "outcome": "Ok",
    "line": 1015,
    "state": "covered",
    "hits": "431"
  },
  {
    "id": "declaration/74/tail/false/tail/false/tail/arm/0/body/block/tail/arm/0/body/block/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1016,
    "state": "covered",
    "hits": "329"
  },
  {
    "id": "declaration/74/tail/false/tail/false/tail/arm/0/body/block/tail/arm/0/body/block/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1016,
    "state": "covered",
    "hits": "102"
  },
  {
    "id": "declaration/74/tail/false/tail/false/tail/arm/0/body/block/tail/arm/0/body/block/statement/0/value/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1016,
    "state": "covered",
    "hits": "431"
  },
  {
    "id": "declaration/74/tail/false/tail/false/tail/arm/0/body/block/tail/arm/0/body/block/statement/0/value/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1016,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/74/tail/false/tail/false/tail/arm/0/body/block/tail/arm/1",
    "outcome": "Error",
    "line": 1020,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/74/tail/false/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1023,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/75/tail/decision/true",
    "outcome": "true",
    "line": 1030,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/75/tail/decision/false",
    "outcome": "false",
    "line": 1030,
    "state": "covered",
    "hits": "12567"
  },
  {
    "id": "declaration/75/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1033,
    "state": "covered",
    "hits": "2653"
  },
  {
    "id": "declaration/75/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1033,
    "state": "covered",
    "hits": "9914"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1036,
    "state": "covered",
    "hits": "2082"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1036,
    "state": "covered",
    "hits": "7832"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1036,
    "state": "covered",
    "hits": "8942"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1036,
    "state": "covered",
    "hits": "972"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/condition/right/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1037,
    "state": "covered",
    "hits": "8268"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/condition/right/decision/skip-right",
    "outcome": "skip-right",
    "line": 1037,
    "state": "covered",
    "hits": "674"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/condition/right/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1037,
    "state": "covered",
    "hits": "8268"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/condition/right/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 1037,
    "state": "covered",
    "hits": "674"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/statement/1/value/decision/true",
    "outcome": "true",
    "line": 1039,
    "state": "covered",
    "hits": "972"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/statement/1/value/decision/false",
    "outcome": "false",
    "line": 1039,
    "state": "covered",
    "hits": "1110"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 1040,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 1040,
    "state": "covered",
    "hits": "2081"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1040,
    "state": "covered",
    "hits": "2082"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1040,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1045,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1045,
    "state": "covered",
    "hits": "2080"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1045,
    "state": "covered",
    "hits": "2081"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1045,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/condition/right/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1045,
    "state": "covered",
    "hits": "35"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/condition/right/decision/skip-right",
    "outcome": "skip-right",
    "line": 1045,
    "state": "covered",
    "hits": "2046"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1048,
    "state": "covered",
    "hits": "2046"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1048,
    "state": "covered",
    "hits": "34"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1052,
    "state": "covered",
    "hits": "2078"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1053,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1053,
    "state": "covered",
    "hits": "2077"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1053,
    "state": "covered",
    "hits": "2078"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1053,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1057,
    "state": "covered",
    "hits": "2077"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1060,
    "state": "covered",
    "hits": "2027"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1060,
    "state": "covered",
    "hits": "50"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1060,
    "state": "covered",
    "hits": "2077"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1060,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1063,
    "state": "covered",
    "hits": "49"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1063,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1063,
    "state": "covered",
    "hits": "50"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1063,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1070,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/true/tail/false/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1074,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1079,
    "state": "covered",
    "hits": "202"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1079,
    "state": "covered",
    "hits": "7630"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1082,
    "state": "covered",
    "hits": "436"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1082,
    "state": "covered",
    "hits": "7194"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1085,
    "state": "covered",
    "hits": "2638"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1085,
    "state": "covered",
    "hits": "4556"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1085,
    "state": "covered",
    "hits": "6520"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1085,
    "state": "covered",
    "hits": "674"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/condition/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1085,
    "state": "covered",
    "hits": "6520"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/condition/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 1085,
    "state": "covered",
    "hits": "674"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 1088,
    "state": "covered",
    "hits": "2638"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1090,
    "state": "covered",
    "hits": "1508"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1090,
    "state": "covered",
    "hits": "1130"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1090,
    "state": "covered",
    "hits": "2638"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1090,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0/body/block/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1093,
    "state": "covered",
    "hits": "1130"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0/body/block/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1093,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0/body/block/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1093,
    "state": "covered",
    "hits": "1130"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/0/body/block/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1093,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 1100,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1104,
    "state": "covered",
    "hits": "4556"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1105,
    "state": "covered",
    "hits": "770"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1105,
    "state": "covered",
    "hits": "3786"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1105,
    "state": "covered",
    "hits": "4556"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1105,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1109,
    "state": "covered",
    "hits": "3784"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1109,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1109,
    "state": "covered",
    "hits": "3786"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1109,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/75/tail/false/tail/false/tail/false/tail/false/tail/false/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1116,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/76/tail/decision/true",
    "outcome": "true",
    "line": 1127,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/76/tail/decision/false",
    "outcome": "false",
    "line": 1127,
    "state": "covered",
    "hits": "6453"
  },
  {
    "id": "declaration/76/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1127,
    "state": "covered",
    "hits": "6457"
  },
  {
    "id": "declaration/76/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1127,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/77/tail/arm/0",
    "outcome": "Ok",
    "line": 1137,
    "state": "covered",
    "hits": "17"
  },
  {
    "id": "declaration/77/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1138,
    "state": "covered",
    "hits": "16"
  },
  {
    "id": "declaration/77/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1138,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/77/tail/arm/1",
    "outcome": "Error",
    "line": 1144,
    "state": "covered",
    "hits": "15"
  },
  {
    "id": "declaration/78/tail/decision/true",
    "outcome": "true",
    "line": 1150,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/78/tail/decision/false",
    "outcome": "false",
    "line": 1150,
    "state": "covered",
    "hits": "47"
  },
  {
    "id": "declaration/78/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1150,
    "state": "covered",
    "hits": "48"
  },
  {
    "id": "declaration/78/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1150,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/78/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1154,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/78/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1154,
    "state": "covered",
    "hits": "46"
  },
  {
    "id": "declaration/78/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1154,
    "state": "covered",
    "hits": "47"
  },
  {
    "id": "declaration/78/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1154,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1158,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1158,
    "state": "covered",
    "hits": "45"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1158,
    "state": "covered",
    "hits": "46"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1158,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1162,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1162,
    "state": "covered",
    "hits": "43"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1162,
    "state": "covered",
    "hits": "45"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1162,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1166,
    "state": "covered",
    "hits": "42"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1168,
    "state": "covered",
    "hits": "11"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1168,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1171,
    "state": "covered",
    "hits": "31"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1171,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/78/tail/false/tail/false/tail/false/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1178,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/79/tail/decision/true",
    "outcome": "true",
    "line": 1187,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/79/tail/decision/false",
    "outcome": "false",
    "line": 1187,
    "state": "covered",
    "hits": "728"
  },
  {
    "id": "declaration/79/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1190,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/79/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1190,
    "state": "covered",
    "hits": "724"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1194,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1194,
    "state": "covered",
    "hits": "723"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1199,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1199,
    "state": "covered",
    "hits": "722"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1199,
    "state": "covered",
    "hits": "723"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1199,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1203,
    "state": "covered",
    "hits": "721"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1206,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1206,
    "state": "covered",
    "hits": "720"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1209,
    "state": "covered",
    "hits": "420"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1209,
    "state": "covered",
    "hits": "300"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1212,
    "state": "covered",
    "hits": "299"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1212,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/79/tail/false/tail/false/tail/false/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1221,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/80/tail/decision/true",
    "outcome": "true",
    "line": 1231,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/80/tail/decision/false",
    "outcome": "false",
    "line": 1231,
    "state": "covered",
    "hits": "312"
  },
  {
    "id": "declaration/80/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1231,
    "state": "covered",
    "hits": "312"
  },
  {
    "id": "declaration/80/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1231,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/80/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1236,
    "state": "covered",
    "hits": "309"
  },
  {
    "id": "declaration/80/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1237,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/80/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1237,
    "state": "covered",
    "hits": "308"
  },
  {
    "id": "declaration/80/tail/false/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1237,
    "state": "covered",
    "hits": "308"
  },
  {
    "id": "declaration/80/tail/false/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1237,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/80/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1244,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/81/tail/decision/true",
    "outcome": "true",
    "line": 1250,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/81/tail/decision/false",
    "outcome": "false",
    "line": 1250,
    "state": "covered",
    "hits": "907"
  },
  {
    "id": "declaration/81/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1253,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/81/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1253,
    "state": "covered",
    "hits": "905"
  },
  {
    "id": "declaration/81/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1257,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/81/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1257,
    "state": "covered",
    "hits": "904"
  },
  {
    "id": "declaration/81/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1262,
    "state": "covered",
    "hits": "386"
  },
  {
    "id": "declaration/81/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1262,
    "state": "covered",
    "hits": "518"
  },
  {
    "id": "declaration/81/tail/false/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1262,
    "state": "covered",
    "hits": "903"
  },
  {
    "id": "declaration/81/tail/false/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1262,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/81/tail/false/tail/false/tail/false/tail/true/tail/arm/0",
    "outcome": "Ok",
    "line": 1264,
    "state": "covered",
    "hits": "382"
  },
  {
    "id": "declaration/81/tail/false/tail/false/tail/false/tail/true/tail/arm/1",
    "outcome": "Error",
    "line": 1265,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/82/tail/decision/true",
    "outcome": "true",
    "line": 1279,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/82/tail/decision/false",
    "outcome": "false",
    "line": 1279,
    "state": "covered",
    "hits": "899"
  },
  {
    "id": "declaration/82/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1282,
    "state": "covered",
    "hits": "520"
  },
  {
    "id": "declaration/82/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1282,
    "state": "covered",
    "hits": "379"
  },
  {
    "id": "declaration/82/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1285,
    "state": "covered",
    "hits": "378"
  },
  {
    "id": "declaration/82/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1285,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/83/tail/decision/true",
    "outcome": "true",
    "line": 1297,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/83/tail/decision/false",
    "outcome": "false",
    "line": 1297,
    "state": "covered",
    "hits": "391"
  },
  {
    "id": "declaration/83/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1297,
    "state": "covered",
    "hits": "391"
  },
  {
    "id": "declaration/83/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1297,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/83/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1302,
    "state": "covered",
    "hits": "388"
  },
  {
    "id": "declaration/83/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1303,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/83/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1303,
    "state": "covered",
    "hits": "387"
  },
  {
    "id": "declaration/83/tail/false/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1303,
    "state": "covered",
    "hits": "387"
  },
  {
    "id": "declaration/83/tail/false/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1303,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/83/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1310,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/84/tail/decision/true",
    "outcome": "true",
    "line": 1316,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/84/tail/decision/false",
    "outcome": "false",
    "line": 1316,
    "state": "covered",
    "hits": "1773"
  },
  {
    "id": "declaration/84/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1319,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/84/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1319,
    "state": "covered",
    "hits": "1771"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1324,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1324,
    "state": "covered",
    "hits": "1770"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1324,
    "state": "covered",
    "hits": "1771"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1324,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1328,
    "state": "covered",
    "hits": "1769"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1331,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1331,
    "state": "covered",
    "hits": "1768"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1334,
    "state": "covered",
    "hits": "973"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1334,
    "state": "covered",
    "hits": "795"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1337,
    "state": "covered",
    "hits": "794"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/false/tail/arm/0/body/block/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1337,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/84/tail/false/tail/false/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1345,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/85/tail/decision/true",
    "outcome": "true",
    "line": 1353,
    "state": "covered",
    "hits": "770"
  },
  {
    "id": "declaration/85/tail/decision/false",
    "outcome": "false",
    "line": 1353,
    "state": "covered",
    "hits": "980"
  },
  {
    "id": "declaration/85/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1353,
    "state": "covered",
    "hits": "1749"
  },
  {
    "id": "declaration/85/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1353,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/86/statement/2/value/decision/true",
    "outcome": "true",
    "line": 1365,
    "state": "covered",
    "hits": "1281"
  },
  {
    "id": "declaration/86/statement/2/value/decision/false",
    "outcome": "false",
    "line": 1365,
    "state": "covered",
    "hits": "477"
  },
  {
    "id": "declaration/86/statement/2/value/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1365,
    "state": "covered",
    "hits": "533"
  },
  {
    "id": "declaration/86/statement/2/value/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1365,
    "state": "covered",
    "hits": "1225"
  },
  {
    "id": "declaration/86/tail/decision/true",
    "outcome": "true",
    "line": 1366,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/86/tail/decision/false",
    "outcome": "false",
    "line": 1366,
    "state": "covered",
    "hits": "1757"
  },
  {
    "id": "declaration/86/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1366,
    "state": "covered",
    "hits": "1757"
  },
  {
    "id": "declaration/86/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1366,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/0",
    "outcome": "Error",
    "line": 1371,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1",
    "outcome": "Ok",
    "line": 1372,
    "state": "covered",
    "hits": "1756"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1374,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1374,
    "state": "covered",
    "hits": "1750"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1374,
    "state": "covered",
    "hits": "1752"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1374,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1378,
    "state": "covered",
    "hits": "1743"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1380,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1380,
    "state": "covered",
    "hits": "1741"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1380,
    "state": "covered",
    "hits": "1743"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1380,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0",
    "outcome": "Ok",
    "line": 1384,
    "state": "covered",
    "hits": "1740"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/arm/0",
    "outcome": "Ok",
    "line": 1386,
    "state": "covered",
    "hits": "1737"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/0/body/block/tail/arm/1",
    "outcome": "Error",
    "line": 1390,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/0/body/block/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1393,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/86/tail/false/tail/arm/1/body/block/tail/false/tail/arm/1",
    "outcome": "Error",
    "line": 1397,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/92/statement/3/decision/body",
    "outcome": "body",
    "line": 1439,
    "state": "covered",
    "hits": "1482"
  },
  {
    "id": "declaration/92/statement/3/decision/exit",
    "outcome": "exit",
    "line": 1439,
    "state": "covered",
    "hits": "103"
  },
  {
    "id": "declaration/92/statement/3/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1440,
    "state": "covered",
    "hits": "29"
  },
  {
    "id": "declaration/92/statement/3/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1440,
    "state": "covered",
    "hits": "1453"
  },
  {
    "id": "declaration/92/statement/3/body/statement/1/value/decision/true",
    "outcome": "true",
    "line": 1441,
    "state": "covered",
    "hits": "88"
  },
  {
    "id": "declaration/92/statement/3/body/statement/1/value/decision/false",
    "outcome": "false",
    "line": 1441,
    "state": "covered",
    "hits": "1394"
  },
  {
    "id": "declaration/92/statement/3/body/statement/1/value/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1441,
    "state": "covered",
    "hits": "88"
  },
  {
    "id": "declaration/92/statement/3/body/statement/1/value/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1441,
    "state": "covered",
    "hits": "1394"
  },
  {
    "id": "declaration/93/tail/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1448,
    "state": "covered",
    "hits": "178"
  },
  {
    "id": "declaration/93/tail/decision/skip-right",
    "outcome": "skip-right",
    "line": 1448,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/93/tail/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1448,
    "state": "covered",
    "hits": "178"
  },
  {
    "id": "declaration/93/tail/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 1448,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/93/tail/left/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1448,
    "state": "covered",
    "hits": "178"
  },
  {
    "id": "declaration/93/tail/left/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 1448,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/93/tail/left/left/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1448,
    "state": "covered",
    "hits": "180"
  },
  {
    "id": "declaration/93/tail/left/left/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 1448,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/94/tail/decision/true",
    "outcome": "true",
    "line": 1453,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/94/tail/decision/false",
    "outcome": "false",
    "line": 1453,
    "state": "covered",
    "hits": "39"
  },
  {
    "id": "declaration/94/tail/false/statement/4/decision/body",
    "outcome": "body",
    "line": 1462,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/94/tail/false/statement/4/decision/exit",
    "outcome": "exit",
    "line": 1462,
    "state": "covered",
    "hits": "39"
  },
  {
    "id": "declaration/94/tail/false/statement/4/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1462,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/94/tail/false/statement/4/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1462,
    "state": "covered",
    "hits": "39"
  },
  {
    "id": "declaration/94/tail/false/statement/4/condition/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1462,
    "state": "covered",
    "hits": "44"
  },
  {
    "id": "declaration/94/tail/false/statement/4/condition/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 1462,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/94/tail/false/statement/5/value/decision/true",
    "outcome": "true",
    "line": 1467,
    "state": "covered",
    "hits": "20"
  },
  {
    "id": "declaration/94/tail/false/statement/5/value/decision/false",
    "outcome": "false",
    "line": 1467,
    "state": "covered",
    "hits": "19"
  },
  {
    "id": "declaration/94/tail/false/statement/5/value/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1467,
    "state": "covered",
    "hits": "39"
  },
  {
    "id": "declaration/94/tail/false/statement/5/value/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1467,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/94/tail/false/statement/5/value/true/tail/decision/true",
    "outcome": "true",
    "line": 1469,
    "state": "covered",
    "hits": "19"
  },
  {
    "id": "declaration/94/tail/false/statement/5/value/true/tail/decision/false",
    "outcome": "false",
    "line": 1469,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/94/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1471,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/94/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1471,
    "state": "covered",
    "hits": "38"
  },
  {
    "id": "declaration/94/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1475,
    "state": "covered",
    "hits": "20"
  },
  {
    "id": "declaration/94/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1475,
    "state": "covered",
    "hits": "18"
  },
  {
    "id": "declaration/94/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1475,
    "state": "covered",
    "hits": "38"
  },
  {
    "id": "declaration/94/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1475,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/94/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1478,
    "state": "covered",
    "hits": "18"
  },
  {
    "id": "declaration/94/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1478,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/94/tail/false/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1478,
    "state": "covered",
    "hits": "18"
  },
  {
    "id": "declaration/94/tail/false/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1478,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/95/tail/decision/true",
    "outcome": "true",
    "line": 1487,
    "state": "covered",
    "hits": "116"
  },
  {
    "id": "declaration/95/tail/decision/false",
    "outcome": "false",
    "line": 1487,
    "state": "covered",
    "hits": "123"
  },
  {
    "id": "declaration/95/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1487,
    "state": "covered",
    "hits": "235"
  },
  {
    "id": "declaration/95/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1487,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/95/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 1488,
    "state": "covered",
    "hits": "115"
  },
  {
    "id": "declaration/95/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 1488,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/95/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1492,
    "state": "covered",
    "hits": "22"
  },
  {
    "id": "declaration/95/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1492,
    "state": "covered",
    "hits": "101"
  },
  {
    "id": "declaration/95/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1492,
    "state": "covered",
    "hits": "119"
  },
  {
    "id": "declaration/95/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1492,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/95/tail/false/tail/true/tail/decision/true",
    "outcome": "true",
    "line": 1493,
    "state": "covered",
    "hits": "22"
  },
  {
    "id": "declaration/95/tail/false/tail/true/tail/decision/false",
    "outcome": "false",
    "line": 1493,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/95/tail/false/tail/true/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1493,
    "state": "covered",
    "hits": "22"
  },
  {
    "id": "declaration/95/tail/false/tail/true/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1493,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/95/tail/false/tail/true/tail/condition/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1493,
    "state": "covered",
    "hits": "22"
  },
  {
    "id": "declaration/95/tail/false/tail/true/tail/condition/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 1493,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/96/tail/decision/true",
    "outcome": "true",
    "line": 1501,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/96/tail/decision/false",
    "outcome": "false",
    "line": 1501,
    "state": "covered",
    "hits": "2512"
  },
  {
    "id": "declaration/96/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1503,
    "state": "covered",
    "hits": "49"
  },
  {
    "id": "declaration/96/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1503,
    "state": "covered",
    "hits": "2463"
  },
  {
    "id": "declaration/96/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1504,
    "state": "covered",
    "hits": "313"
  },
  {
    "id": "declaration/96/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1504,
    "state": "covered",
    "hits": "2150"
  },
  {
    "id": "declaration/96/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1505,
    "state": "covered",
    "hits": "392"
  },
  {
    "id": "declaration/96/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1505,
    "state": "covered",
    "hits": "1758"
  },
  {
    "id": "declaration/96/tail/false/tail/false/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1506,
    "state": "covered",
    "hits": "1758"
  },
  {
    "id": "declaration/96/tail/false/tail/false/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1506,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/97/tail/decision/true",
    "outcome": "true",
    "line": 1512,
    "state": "covered",
    "hits": "884"
  },
  {
    "id": "declaration/97/tail/decision/false",
    "outcome": "false",
    "line": 1512,
    "state": "covered",
    "hits": "4099"
  },
  {
    "id": "declaration/97/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1514,
    "state": "covered",
    "hits": "1344"
  },
  {
    "id": "declaration/97/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1514,
    "state": "covered",
    "hits": "2755"
  },
  {
    "id": "declaration/97/tail/false/tail/false/statement/1/value/decision/true",
    "outcome": "true",
    "line": 1517,
    "state": "covered",
    "hits": "355"
  },
  {
    "id": "declaration/97/tail/false/tail/false/statement/1/value/decision/false",
    "outcome": "false",
    "line": 1517,
    "state": "covered",
    "hits": "2400"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/decision/true",
    "outcome": "true",
    "line": 1518,
    "state": "covered",
    "hits": "243"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/decision/false",
    "outcome": "false",
    "line": 1518,
    "state": "covered",
    "hits": "2512"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1518,
    "state": "covered",
    "hits": "2755"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1518,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/0",
    "outcome": "Error",
    "line": 1520,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1",
    "outcome": "Ok",
    "line": 1521,
    "state": "covered",
    "hits": "239"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1/body/arm/0",
    "outcome": "Error",
    "line": 1522,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1/body/arm/1",
    "outcome": "Ok",
    "line": 1523,
    "state": "covered",
    "hits": "236"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1/body/arm/1/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1525,
    "state": "covered",
    "hits": "236"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1/body/arm/1/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1525,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1/body/arm/1/body/block/tail/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1525,
    "state": "covered",
    "hits": "208"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1/body/arm/1/body/block/tail/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1525,
    "state": "covered",
    "hits": "28"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1/body/arm/1/body/block/tail/true/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1526,
    "state": "covered",
    "hits": "28"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/true/tail/arm/1/body/arm/1/body/block/tail/true/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1526,
    "state": "covered",
    "hits": "208"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/false/tail/arm/0",
    "outcome": "Error",
    "line": 1534,
    "state": "covered",
    "hits": "50"
  },
  {
    "id": "declaration/97/tail/false/tail/false/tail/false/tail/arm/1",
    "outcome": "Ok",
    "line": 1535,
    "state": "covered",
    "hits": "2462"
  },
  {
    "id": "declaration/99/statement/1/decision/body",
    "outcome": "body",
    "line": 1555,
    "state": "covered",
    "hits": "2947"
  },
  {
    "id": "declaration/99/statement/1/decision/exit",
    "outcome": "exit",
    "line": 1555,
    "state": "covered",
    "hits": "626"
  },
  {
    "id": "declaration/99/statement/1/body/tail/arm/0",
    "outcome": "NamespaceImportBinding",
    "line": 1557,
    "state": "covered",
    "hits": "173"
  },
  {
    "id": "declaration/99/statement/1/body/tail/arm/1",
    "outcome": "NoImportBinding",
    "line": 1558,
    "state": "covered",
    "hits": "2768"
  },
  {
    "id": "declaration/99/statement/1/body/tail/arm/2",
    "outcome": "SelectiveImportBinding",
    "line": 1558,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/99/statement/2/decision/body",
    "outcome": "body",
    "line": 1561,
    "state": "covered",
    "hits": "2947"
  },
  {
    "id": "declaration/99/statement/2/decision/exit",
    "outcome": "exit",
    "line": 1561,
    "state": "covered",
    "hits": "626"
  },
  {
    "id": "declaration/99/statement/2/body/tail/arm/0",
    "outcome": "EnumDeclaration",
    "line": 1563,
    "state": "covered",
    "hits": "386"
  },
  {
    "id": "declaration/99/statement/2/body/tail/arm/1",
    "outcome": "ImportDeclaration",
    "line": 1564,
    "state": "covered",
    "hits": "179"
  },
  {
    "id": "declaration/99/statement/2/body/tail/arm/2",
    "outcome": "TypeDeclaration",
    "line": 1564,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/99/statement/2/body/tail/arm/3",
    "outcome": "RecordDeclaration",
    "line": 1565,
    "state": "covered",
    "hits": "378"
  },
  {
    "id": "declaration/99/statement/2/body/tail/arm/4",
    "outcome": "FunctionDeclaration",
    "line": 1566,
    "state": "covered",
    "hits": "1972"
  },
  {
    "id": "declaration/99/statement/5/decision/body",
    "outcome": "body",
    "line": 1571,
    "state": "covered",
    "hits": "2947"
  },
  {
    "id": "declaration/99/statement/5/decision/exit",
    "outcome": "exit",
    "line": 1571,
    "state": "covered",
    "hits": "626"
  },
  {
    "id": "declaration/99/statement/5/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1572,
    "state": "covered",
    "hits": "2935"
  },
  {
    "id": "declaration/99/statement/5/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 1572,
    "state": "covered",
    "hits": "12"
  },
  {
    "id": "declaration/99/statement/5/body/statement/1/value/arm/0",
    "outcome": "NoImportBinding",
    "line": 1574,
    "state": "covered",
    "hits": "2768"
  },
  {
    "id": "declaration/99/statement/5/body/statement/1/value/arm/1",
    "outcome": "NamespaceImportBinding",
    "line": 1575,
    "state": "covered",
    "hits": "173"
  },
  {
    "id": "declaration/99/statement/5/body/statement/1/value/arm/1/body/block/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1575,
    "state": "covered",
    "hits": "168"
  },
  {
    "id": "declaration/99/statement/5/body/statement/1/value/arm/1/body/block/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 1575,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/99/statement/5/body/statement/1/value/arm/2",
    "outcome": "SelectiveImportBinding",
    "line": 1576,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/99/statement/5/body/statement/2/value/decision/true",
    "outcome": "true",
    "line": 1578,
    "state": "covered",
    "hits": "39"
  },
  {
    "id": "declaration/99/statement/5/body/statement/2/value/decision/false",
    "outcome": "false",
    "line": 1578,
    "state": "covered",
    "hits": "2908"
  },
  {
    "id": "declaration/100/tail/arm/0",
    "outcome": "Error",
    "line": 1588,
    "state": "covered",
    "hits": "54"
  },
  {
    "id": "declaration/100/tail/arm/1",
    "outcome": "Ok",
    "line": 1589,
    "state": "covered",
    "hits": "440"
  },
  {
    "id": "declaration/100/tail/arm/1/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1591,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/100/tail/arm/1/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1591,
    "state": "covered",
    "hits": "408"
  },
  {
    "id": "declaration/101/statement/2/decision/body",
    "outcome": "body",
    "line": 1599,
    "state": "covered",
    "hits": "59"
  },
  {
    "id": "declaration/101/statement/2/decision/exit",
    "outcome": "exit",
    "line": 1599,
    "state": "covered",
    "hits": "46"
  },
  {
    "id": "declaration/101/statement/2/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1600,
    "state": "covered",
    "hits": "40"
  },
  {
    "id": "declaration/101/statement/2/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1600,
    "state": "covered",
    "hits": "19"
  },
  {
    "id": "declaration/102/statement/2/decision/body",
    "outcome": "body",
    "line": 1613,
    "state": "covered",
    "hits": "9"
  },
  {
    "id": "declaration/102/statement/2/decision/exit",
    "outcome": "exit",
    "line": 1613,
    "state": "covered",
    "hits": "13"
  },
  {
    "id": "declaration/102/statement/2/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1614,
    "state": "covered",
    "hits": "8"
  },
  {
    "id": "declaration/102/statement/2/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1614,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/104/statement/2/decision/body",
    "outcome": "body",
    "line": 1634,
    "state": "covered",
    "hits": "13"
  },
  {
    "id": "declaration/104/statement/2/decision/exit",
    "outcome": "exit",
    "line": 1634,
    "state": "covered",
    "hits": "8"
  },
  {
    "id": "declaration/104/statement/2/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1635,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/104/statement/2/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1635,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/105/tail/arm/0",
    "outcome": "LocatedExpr",
    "line": 1647,
    "state": "covered",
    "hits": "306"
  },
  {
    "id": "declaration/105/tail/arm/1",
    "outcome": "NatExpr",
    "line": 1648,
    "state": "covered",
    "hits": "74"
  },
  {
    "id": "declaration/105/tail/arm/2",
    "outcome": "DecimalExpr",
    "line": 1649,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/105/tail/arm/3",
    "outcome": "StringExpr",
    "line": 1650,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/105/tail/arm/4",
    "outcome": "BoolExpr",
    "line": 1651,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/105/tail/arm/4/body/decision/true",
    "outcome": "true",
    "line": 1651,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/105/tail/arm/4/body/decision/false",
    "outcome": "false",
    "line": 1651,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/105/tail/arm/5",
    "outcome": "NameExpr",
    "line": 1652,
    "state": "covered",
    "hits": "96"
  },
  {
    "id": "declaration/105/tail/arm/6",
    "outcome": "FunctionExpr",
    "line": 1653,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/105/tail/arm/7",
    "outcome": "ArrayExpr",
    "line": 1654,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/105/tail/arm/8",
    "outcome": "UnaryExpr",
    "line": 1658,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/105/tail/arm/8/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1660,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/105/tail/arm/8/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1660,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/105/tail/arm/9",
    "outcome": "BinaryExpr",
    "line": 1662,
    "state": "covered",
    "hits": "45"
  },
  {
    "id": "declaration/105/tail/arm/10",
    "outcome": "CallExpr",
    "line": 1667,
    "state": "covered",
    "hits": "43"
  },
  {
    "id": "declaration/105/tail/arm/11",
    "outcome": "DotCallExpr",
    "line": 1672,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/105/tail/arm/12",
    "outcome": "FieldExpr",
    "line": 1673,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/105/tail/arm/13",
    "outcome": "IndexExpr",
    "line": 1677,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/105/tail/arm/14",
    "outcome": "IfExpr",
    "line": 1682,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/105/tail/arm/14/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1685,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/105/tail/arm/14/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1685,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/105/tail/arm/15",
    "outcome": "BlockExpr",
    "line": 1692,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/105/tail/arm/16",
    "outcome": "MatchExpr",
    "line": 1693,
    "state": "covered",
    "hits": "8"
  },
  {
    "id": "declaration/105/tail/arm/16/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1696,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/105/tail/arm/16/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1696,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/106/tail/arm/0",
    "outcome": "BindingStatement",
    "line": 1707,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/106/tail/arm/0/body/block/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1708,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/106/tail/arm/0/body/block/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1708,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/106/tail/arm/0/body/block/statement/2/value/decision/true",
    "outcome": "true",
    "line": 1710,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/106/tail/arm/0/body/block/statement/2/value/decision/false",
    "outcome": "false",
    "line": 1710,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/106/tail/arm/1",
    "outcome": "AssignmentStatement",
    "line": 1713,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/106/tail/arm/2",
    "outcome": "ExpressionStatement",
    "line": 1717,
    "state": "covered",
    "hits": "16"
  },
  {
    "id": "declaration/106/tail/arm/3",
    "outcome": "WhileStatement",
    "line": 1721,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/106/tail/arm/4",
    "outcome": "ForStatement",
    "line": 1726,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/107/statement/1/decision/body",
    "outcome": "body",
    "line": 1736,
    "state": "covered",
    "hits": "34"
  },
  {
    "id": "declaration/107/statement/1/decision/exit",
    "outcome": "exit",
    "line": 1736,
    "state": "covered",
    "hits": "44"
  },
  {
    "id": "declaration/107/statement/1/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1737,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/107/statement/1/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1737,
    "state": "covered",
    "hits": "27"
  },
  {
    "id": "declaration/107/statement/2/value/arm/0",
    "outcome": "NoBlockValue",
    "line": 1744,
    "state": "covered",
    "hits": "19"
  },
  {
    "id": "declaration/107/statement/2/value/arm/1",
    "outcome": "TailBlockValue",
    "line": 1745,
    "state": "covered",
    "hits": "25"
  },
  {
    "id": "declaration/107/statement/2/value/arm/1/body/block/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1746,
    "state": "covered",
    "hits": "10"
  },
  {
    "id": "declaration/107/statement/2/value/arm/1/body/block/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1746,
    "state": "covered",
    "hits": "15"
  },
  {
    "id": "declaration/107/tail/decision/true",
    "outcome": "true",
    "line": 1753,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/107/tail/decision/false",
    "outcome": "false",
    "line": 1753,
    "state": "covered",
    "hits": "42"
  },
  {
    "id": "declaration/108/tail/decision/true",
    "outcome": "true",
    "line": 1757,
    "state": "covered",
    "hits": "51"
  },
  {
    "id": "declaration/108/tail/decision/false",
    "outcome": "false",
    "line": 1757,
    "state": "covered",
    "hits": "11"
  },
  {
    "id": "declaration/109/statement/2/decision/body",
    "outcome": "body",
    "line": 1768,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/109/statement/2/decision/exit",
    "outcome": "exit",
    "line": 1768,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/109/statement/2/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1769,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/109/statement/2/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1769,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/110/tail/decision/true",
    "outcome": "true",
    "line": 1784,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/110/tail/decision/false",
    "outcome": "false",
    "line": 1784,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/111/statement/2/decision/body",
    "outcome": "body",
    "line": 1794,
    "state": "covered",
    "hits": "12"
  },
  {
    "id": "declaration/111/statement/2/decision/exit",
    "outcome": "exit",
    "line": 1794,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/111/statement/2/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1795,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/111/statement/2/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1795,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/111/statement/2/body/tail/decision/true",
    "outcome": "true",
    "line": 1801,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/111/statement/2/body/tail/decision/false",
    "outcome": "false",
    "line": 1801,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/112/tail/decision/true",
    "outcome": "true",
    "line": 1814,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/112/tail/decision/false",
    "outcome": "false",
    "line": 1814,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/113/statement/2/decision/body",
    "outcome": "body",
    "line": 1824,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/113/statement/2/decision/exit",
    "outcome": "exit",
    "line": 1824,
    "state": "covered",
    "hits": "8"
  },
  {
    "id": "declaration/113/statement/2/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1825,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/113/statement/2/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1825,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/114/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1838,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/114/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1838,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/115/tail/arm/0",
    "outcome": "ImportDeclaration",
    "line": 1846,
    "state": "covered",
    "hits": "10"
  },
  {
    "id": "declaration/115/tail/arm/1",
    "outcome": "TypeDeclaration",
    "line": 1847,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/115/tail/arm/2",
    "outcome": "RecordDeclaration",
    "line": 1851,
    "state": "covered",
    "hits": "5"
  },
  {
    "id": "declaration/115/tail/arm/3",
    "outcome": "EnumDeclaration",
    "line": 1852,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/115/tail/arm/4",
    "outcome": "FunctionDeclaration",
    "line": 1853,
    "state": "covered",
    "hits": "8"
  },
  {
    "id": "declaration/115/tail/arm/4/body/block/tail/decision/true",
    "outcome": "true",
    "line": 1856,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/115/tail/arm/4/body/block/tail/decision/false",
    "outcome": "false",
    "line": 1856,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/116/statement/1/decision/body",
    "outcome": "body",
    "line": 1863,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/116/statement/1/decision/exit",
    "outcome": "exit",
    "line": 1863,
    "state": "covered",
    "hits": "25"
  },
  {
    "id": "declaration/116/statement/1/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1864,
    "state": "covered",
    "hits": "8"
  },
  {
    "id": "declaration/116/statement/1/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1864,
    "state": "covered",
    "hits": "24"
  },
  {
    "id": "declaration/117/tail/arm/0",
    "outcome": "Ok",
    "line": 1875,
    "state": "covered",
    "hits": "78"
  },
  {
    "id": "declaration/117/tail/arm/0/body/block/tail/arm/0",
    "outcome": "Ok",
    "line": 1877,
    "state": "covered",
    "hits": "54"
  },
  {
    "id": "declaration/117/tail/arm/0/body/block/tail/arm/1",
    "outcome": "Error",
    "line": 1878,
    "state": "covered",
    "hits": "24"
  },
  {
    "id": "declaration/117/tail/arm/1",
    "outcome": "Error",
    "line": 1881,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/118/tail/arm/0",
    "outcome": "Ok",
    "line": 1887,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/118/tail/arm/0/body/block/tail/arm/0",
    "outcome": "Ok",
    "line": 1889,
    "state": "covered",
    "hits": "16"
  },
  {
    "id": "declaration/118/tail/arm/0/body/block/tail/arm/1",
    "outcome": "Error",
    "line": 1890,
    "state": "covered",
    "hits": "16"
  },
  {
    "id": "declaration/118/tail/arm/1",
    "outcome": "Error",
    "line": 1893,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/119/tail/arm/0",
    "outcome": "Ok",
    "line": 1899,
    "state": "covered",
    "hits": "72"
  },
  {
    "id": "declaration/119/tail/arm/0/body/block/tail/arm/0",
    "outcome": "Ok",
    "line": 1901,
    "state": "covered",
    "hits": "25"
  },
  {
    "id": "declaration/119/tail/arm/0/body/block/tail/arm/1",
    "outcome": "Error",
    "line": 1902,
    "state": "covered",
    "hits": "47"
  },
  {
    "id": "declaration/119/tail/arm/1",
    "outcome": "Error",
    "line": 1905,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/120/tail/arm/0",
    "outcome": "Ok",
    "line": 1911,
    "state": "covered",
    "hits": "11"
  },
  {
    "id": "declaration/120/tail/arm/0/body/block/tail/arm/0",
    "outcome": "Ok",
    "line": 1913,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/120/tail/arm/0/body/block/tail/arm/1",
    "outcome": "Error",
    "line": 1914,
    "state": "covered",
    "hits": "7"
  },
  {
    "id": "declaration/120/tail/arm/1",
    "outcome": "Error",
    "line": 1917,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/121/statement/1/decision/body",
    "outcome": "body",
    "line": 1924,
    "state": "covered",
    "hits": "8322"
  },
  {
    "id": "declaration/121/statement/1/decision/exit",
    "outcome": "exit",
    "line": 1924,
    "state": "covered",
    "hits": "19"
  },
  {
    "id": "declaration/121/statement/1/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 1925,
    "state": "covered",
    "hits": "95"
  },
  {
    "id": "declaration/121/statement/1/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 1925,
    "state": "covered",
    "hits": "8227"
  },
  {
    "id": "declaration/121/statement/1/body/statement/0/value/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1925,
    "state": "covered",
    "hits": "3268"
  },
  {
    "id": "declaration/121/statement/1/body/statement/0/value/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 1925,
    "state": "covered",
    "hits": "5054"
  },
  {
    "id": "declaration/121/statement/1/body/statement/0/value/condition/right/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1926,
    "state": "covered",
    "hits": "3230"
  },
  {
    "id": "declaration/121/statement/1/body/statement/0/value/condition/right/decision/skip-right",
    "outcome": "skip-right",
    "line": 1926,
    "state": "covered",
    "hits": "38"
  },
  {
    "id": "declaration/121/statement/1/body/statement/0/value/condition/right/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 1926,
    "state": "covered",
    "hits": "3249"
  },
  {
    "id": "declaration/121/statement/1/body/statement/0/value/condition/right/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 1926,
    "state": "covered",
    "hits": "19"
  },
  {
    "id": "declaration/122/statement/1/decision/body",
    "outcome": "body",
    "line": 1939,
    "state": "covered",
    "hits": "11700"
  },
  {
    "id": "declaration/122/statement/1/decision/exit",
    "outcome": "exit",
    "line": 1939,
    "state": "covered",
    "hits": "7477"
  },
  {
    "id": "declaration/123/tail/arm/0",
    "outcome": "LocatedExpr",
    "line": 1945,
    "state": "covered",
    "hits": "38969"
  },
  {
    "id": "declaration/123/tail/arm/1",
    "outcome": "DotCallExpr",
    "line": 1946,
    "state": "covered",
    "hits": "589"
  },
  {
    "id": "declaration/123/tail/arm/2",
    "outcome": "ArrayExpr",
    "line": 1947,
    "state": "covered",
    "hits": "556"
  },
  {
    "id": "declaration/123/tail/arm/3",
    "outcome": "UnaryExpr",
    "line": 1948,
    "state": "covered",
    "hits": "228"
  },
  {
    "id": "declaration/123/tail/arm/4",
    "outcome": "BinaryExpr",
    "line": 1949,
    "state": "covered",
    "hits": "4720"
  },
  {
    "id": "declaration/123/tail/arm/5",
    "outcome": "CallExpr",
    "line": 1950,
    "state": "covered",
    "hits": "6332"
  },
  {
    "id": "declaration/123/tail/arm/6",
    "outcome": "FieldExpr",
    "line": 1951,
    "state": "covered",
    "hits": "3159"
  },
  {
    "id": "declaration/123/tail/arm/7",
    "outcome": "IndexExpr",
    "line": 1952,
    "state": "covered",
    "hits": "661"
  },
  {
    "id": "declaration/123/tail/arm/8",
    "outcome": "IfExpr",
    "line": 1953,
    "state": "covered",
    "hits": "1619"
  },
  {
    "id": "declaration/123/tail/arm/9",
    "outcome": "BlockExpr",
    "line": 1954,
    "state": "covered",
    "hits": "1015"
  },
  {
    "id": "declaration/123/tail/arm/10",
    "outcome": "MatchExpr",
    "line": 1955,
    "state": "covered",
    "hits": "425"
  },
  {
    "id": "declaration/123/tail/arm/10/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 1957,
    "state": "covered",
    "hits": "1684"
  },
  {
    "id": "declaration/123/tail/arm/10/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 1957,
    "state": "covered",
    "hits": "425"
  },
  {
    "id": "declaration/123/tail/arm/11",
    "outcome": "NatExpr",
    "line": 1960,
    "state": "covered",
    "hits": "2452"
  },
  {
    "id": "declaration/123/tail/arm/12",
    "outcome": "DecimalExpr",
    "line": 1960,
    "state": "covered",
    "hits": "15"
  },
  {
    "id": "declaration/123/tail/arm/13",
    "outcome": "StringExpr",
    "line": 1960,
    "state": "covered",
    "hits": "2550"
  },
  {
    "id": "declaration/123/tail/arm/14",
    "outcome": "BoolExpr",
    "line": 1961,
    "state": "covered",
    "hits": "587"
  },
  {
    "id": "declaration/123/tail/arm/15",
    "outcome": "NameExpr",
    "line": 1961,
    "state": "covered",
    "hits": "14000"
  },
  {
    "id": "declaration/123/tail/arm/16",
    "outcome": "FunctionExpr",
    "line": 1961,
    "state": "covered",
    "hits": "61"
  },
  {
    "id": "declaration/124/statement/1/decision/body",
    "outcome": "body",
    "line": 1967,
    "state": "covered",
    "hits": "5485"
  },
  {
    "id": "declaration/124/statement/1/decision/exit",
    "outcome": "exit",
    "line": 1967,
    "state": "covered",
    "hits": "6053"
  },
  {
    "id": "declaration/124/statement/1/body/statement/0/value/arm/0",
    "outcome": "BindingStatement",
    "line": 1969,
    "state": "covered",
    "hits": "1936"
  },
  {
    "id": "declaration/124/statement/1/body/statement/0/value/arm/1",
    "outcome": "AssignmentStatement",
    "line": 1970,
    "state": "covered",
    "hits": "2286"
  },
  {
    "id": "declaration/124/statement/1/body/statement/0/value/arm/2",
    "outcome": "ExpressionStatement",
    "line": 1971,
    "state": "covered",
    "hits": "748"
  },
  {
    "id": "declaration/124/statement/1/body/statement/0/value/arm/3",
    "outcome": "WhileStatement",
    "line": 1972,
    "state": "covered",
    "hits": "136"
  },
  {
    "id": "declaration/124/statement/1/body/statement/0/value/arm/4",
    "outcome": "ForStatement",
    "line": 1973,
    "state": "covered",
    "hits": "379"
  },
  {
    "id": "declaration/124/statement/2/value/arm/0",
    "outcome": "NoBlockValue",
    "line": 1978,
    "state": "covered",
    "hits": "2863"
  },
  {
    "id": "declaration/124/statement/2/value/arm/1",
    "outcome": "TailBlockValue",
    "line": 1979,
    "state": "covered",
    "hits": "3190"
  },
  {
    "id": "declaration/125/statement/1/decision/body",
    "outcome": "body",
    "line": 1986,
    "state": "covered",
    "hits": "1962"
  },
  {
    "id": "declaration/125/statement/1/decision/exit",
    "outcome": "exit",
    "line": 1986,
    "state": "covered",
    "hits": "498"
  },
  {
    "id": "declaration/125/statement/1/body/statement/0/value/arm/0",
    "outcome": "TypeDeclaration",
    "line": 1988,
    "state": "covered",
    "hits": "29"
  },
  {
    "id": "declaration/125/statement/1/body/statement/0/value/arm/1",
    "outcome": "FunctionDeclaration",
    "line": 1989,
    "state": "covered",
    "hits": "1285"
  },
  {
    "id": "declaration/125/statement/1/body/statement/0/value/arm/2",
    "outcome": "ImportDeclaration",
    "line": 1990,
    "state": "covered",
    "hits": "90"
  },
  {
    "id": "declaration/125/statement/1/body/statement/0/value/arm/3",
    "outcome": "RecordDeclaration",
    "line": 1991,
    "state": "covered",
    "hits": "254"
  },
  {
    "id": "declaration/125/statement/1/body/statement/0/value/arm/4",
    "outcome": "EnumDeclaration",
    "line": 1992,
    "state": "covered",
    "hits": "304"
  },
  {
    "id": "declaration/126/statement/1/decision/body",
    "outcome": "body",
    "line": 2001,
    "state": "covered",
    "hits": "48382"
  },
  {
    "id": "declaration/126/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2001,
    "state": "covered",
    "hits": "8419"
  },
  {
    "id": "declaration/126/statement/1/condition/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2001,
    "state": "covered",
    "hits": "49330"
  },
  {
    "id": "declaration/126/statement/1/condition/decision/skip-right",
    "outcome": "skip-right",
    "line": 2001,
    "state": "covered",
    "hits": "7471"
  },
  {
    "id": "declaration/127/tail/decision/true",
    "outcome": "true",
    "line": 2007,
    "state": "covered",
    "hits": "136"
  },
  {
    "id": "declaration/127/tail/decision/false",
    "outcome": "false",
    "line": 2007,
    "state": "covered",
    "hits": "317"
  },
  {
    "id": "declaration/128/tail/arm/0",
    "outcome": "LocatedExpr",
    "line": 2012,
    "state": "covered",
    "hits": "8209"
  },
  {
    "id": "declaration/128/tail/arm/1",
    "outcome": "NameExpr",
    "line": 2013,
    "state": "covered",
    "hits": "6839"
  },
  {
    "id": "declaration/128/tail/arm/2",
    "outcome": "FieldExpr",
    "line": 2014,
    "state": "covered",
    "hits": "724"
  },
  {
    "id": "declaration/128/tail/arm/2/body/block/tail/decision/true",
    "outcome": "true",
    "line": 2016,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/128/tail/arm/2/body/block/tail/decision/false",
    "outcome": "false",
    "line": 2016,
    "state": "covered",
    "hits": "720"
  },
  {
    "id": "declaration/128/tail/arm/3",
    "outcome": "NatExpr",
    "line": 2018,
    "state": "covered",
    "hits": "6"
  },
  {
    "id": "declaration/128/tail/arm/4",
    "outcome": "DecimalExpr",
    "line": 2018,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/128/tail/arm/5",
    "outcome": "StringExpr",
    "line": 2018,
    "state": "covered",
    "hits": "13"
  },
  {
    "id": "declaration/128/tail/arm/6",
    "outcome": "BoolExpr",
    "line": 2018,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/128/tail/arm/7",
    "outcome": "FunctionExpr",
    "line": 2019,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/128/tail/arm/8",
    "outcome": "ArrayExpr",
    "line": 2019,
    "state": "covered",
    "hits": "24"
  },
  {
    "id": "declaration/128/tail/arm/9",
    "outcome": "UnaryExpr",
    "line": 2019,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/128/tail/arm/10",
    "outcome": "BinaryExpr",
    "line": 2020,
    "state": "covered",
    "hits": "43"
  },
  {
    "id": "declaration/128/tail/arm/11",
    "outcome": "CallExpr",
    "line": 2020,
    "state": "covered",
    "hits": "57"
  },
  {
    "id": "declaration/128/tail/arm/12",
    "outcome": "DotCallExpr",
    "line": 2021,
    "state": "covered",
    "hits": "20"
  },
  {
    "id": "declaration/128/tail/arm/13",
    "outcome": "IndexExpr",
    "line": 2021,
    "state": "covered",
    "hits": "498"
  },
  {
    "id": "declaration/128/tail/arm/14",
    "outcome": "IfExpr",
    "line": 2022,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/128/tail/arm/15",
    "outcome": "BlockExpr",
    "line": 2022,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/128/tail/arm/16",
    "outcome": "MatchExpr",
    "line": 2022,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/129/statement/2/decision/body",
    "outcome": "body",
    "line": 2029,
    "state": "covered",
    "hits": "238017"
  },
  {
    "id": "declaration/129/statement/2/decision/exit",
    "outcome": "exit",
    "line": 2029,
    "state": "covered",
    "hits": "25769"
  },
  {
    "id": "declaration/129/statement/2/body/statement/0/value/decision/true",
    "outcome": "true",
    "line": 2029,
    "state": "covered",
    "hits": "18"
  },
  {
    "id": "declaration/129/statement/2/body/statement/0/value/decision/false",
    "outcome": "false",
    "line": 2029,
    "state": "covered",
    "hits": "237999"
  },
  {
    "id": "declaration/130/tail/arm/0",
    "outcome": "LocatedExpr",
    "line": 2037,
    "state": "covered",
    "hits": "75060"
  },
  {
    "id": "declaration/130/tail/arm/1",
    "outcome": "DotCallExpr",
    "line": 2038,
    "state": "covered",
    "hits": "1072"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2039,
    "state": "covered",
    "hits": "1062"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2039,
    "state": "covered",
    "hits": "10"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/0/value/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2039,
    "state": "covered",
    "hits": "18"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/0/value/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 2039,
    "state": "covered",
    "hits": "1054"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 2040,
    "state": "covered",
    "hits": "782"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2040,
    "state": "covered",
    "hits": "1072"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/1/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2040,
    "state": "covered",
    "hits": "778"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/1/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2040,
    "state": "covered",
    "hits": "4"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/2/decision/body",
    "outcome": "body",
    "line": 2041,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/2/decision/exit",
    "outcome": "exit",
    "line": 2041,
    "state": "covered",
    "hits": "1072"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/2/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2041,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/130/tail/arm/1/body/block/statement/2/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2041,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/2",
    "outcome": "FieldExpr",
    "line": 2044,
    "state": "covered",
    "hits": "6292"
  },
  {
    "id": "declaration/130/tail/arm/2/body/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2044,
    "state": "covered",
    "hits": "6292"
  },
  {
    "id": "declaration/130/tail/arm/2/body/decision/skip-right",
    "outcome": "skip-right",
    "line": 2044,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/2/body/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2044,
    "state": "covered",
    "hits": "1"
  },
  {
    "id": "declaration/130/tail/arm/2/body/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 2044,
    "state": "covered",
    "hits": "6291"
  },
  {
    "id": "declaration/130/tail/arm/3",
    "outcome": "FunctionExpr",
    "line": 2045,
    "state": "covered",
    "hits": "75"
  },
  {
    "id": "declaration/130/tail/arm/4",
    "outcome": "CallExpr",
    "line": 2046,
    "state": "covered",
    "hits": "12159"
  },
  {
    "id": "declaration/130/tail/arm/4/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 2048,
    "state": "covered",
    "hits": "21595"
  },
  {
    "id": "declaration/130/tail/arm/4/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2048,
    "state": "covered",
    "hits": "12159"
  },
  {
    "id": "declaration/130/tail/arm/4/body/block/statement/1/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2048,
    "state": "covered",
    "hits": "21595"
  },
  {
    "id": "declaration/130/tail/arm/4/body/block/statement/1/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2048,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/4/body/block/statement/2/decision/body",
    "outcome": "body",
    "line": 2049,
    "state": "covered",
    "hits": "46"
  },
  {
    "id": "declaration/130/tail/arm/4/body/block/statement/2/decision/exit",
    "outcome": "exit",
    "line": 2049,
    "state": "covered",
    "hits": "12159"
  },
  {
    "id": "declaration/130/tail/arm/4/body/block/statement/2/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2049,
    "state": "covered",
    "hits": "46"
  },
  {
    "id": "declaration/130/tail/arm/4/body/block/statement/2/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2049,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/5",
    "outcome": "ArrayExpr",
    "line": 2052,
    "state": "covered",
    "hits": "1032"
  },
  {
    "id": "declaration/130/tail/arm/5/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 2052,
    "state": "covered",
    "hits": "433"
  },
  {
    "id": "declaration/130/tail/arm/5/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2052,
    "state": "covered",
    "hits": "1032"
  },
  {
    "id": "declaration/130/tail/arm/5/body/block/statement/1/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2052,
    "state": "covered",
    "hits": "433"
  },
  {
    "id": "declaration/130/tail/arm/5/body/block/statement/1/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2052,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/6",
    "outcome": "UnaryExpr",
    "line": 2053,
    "state": "covered",
    "hits": "404"
  },
  {
    "id": "declaration/130/tail/arm/7",
    "outcome": "BinaryExpr",
    "line": 2054,
    "state": "covered",
    "hits": "9108"
  },
  {
    "id": "declaration/130/tail/arm/7/body/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2054,
    "state": "covered",
    "hits": "9108"
  },
  {
    "id": "declaration/130/tail/arm/7/body/decision/skip-right",
    "outcome": "skip-right",
    "line": 2054,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/8",
    "outcome": "IndexExpr",
    "line": 2055,
    "state": "covered",
    "hits": "1288"
  },
  {
    "id": "declaration/130/tail/arm/8/body/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2055,
    "state": "covered",
    "hits": "1288"
  },
  {
    "id": "declaration/130/tail/arm/8/body/decision/skip-right",
    "outcome": "skip-right",
    "line": 2055,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/9",
    "outcome": "IfExpr",
    "line": 2056,
    "state": "covered",
    "hits": "3143"
  },
  {
    "id": "declaration/130/tail/arm/9/body/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2056,
    "state": "covered",
    "hits": "3143"
  },
  {
    "id": "declaration/130/tail/arm/9/body/decision/skip-right",
    "outcome": "skip-right",
    "line": 2056,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/9/body/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2056,
    "state": "covered",
    "hits": "3143"
  },
  {
    "id": "declaration/130/tail/arm/9/body/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 2056,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/10",
    "outcome": "BlockExpr",
    "line": 2057,
    "state": "covered",
    "hits": "2021"
  },
  {
    "id": "declaration/130/tail/arm/11",
    "outcome": "MatchExpr",
    "line": 2058,
    "state": "covered",
    "hits": "821"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 2060,
    "state": "covered",
    "hits": "3317"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2060,
    "state": "covered",
    "hits": "821"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/body/statement/1/decision/body",
    "outcome": "body",
    "line": 2062,
    "state": "covered",
    "hits": "4836"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/body/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2062,
    "state": "covered",
    "hits": "3317"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/body/statement/1/body/tail/decision/true",
    "outcome": "true",
    "line": 2062,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/body/statement/1/body/tail/decision/false",
    "outcome": "false",
    "line": 2062,
    "state": "covered",
    "hits": "4834"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/body/statement/2/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2063,
    "state": "covered",
    "hits": "3315"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/body/statement/2/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2063,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/body/statement/2/value/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2063,
    "state": "covered",
    "hits": "3317"
  },
  {
    "id": "declaration/130/tail/arm/11/body/block/statement/1/body/statement/2/value/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 2063,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/130/tail/arm/12",
    "outcome": "NatExpr",
    "line": 2067,
    "state": "covered",
    "hits": "4131"
  },
  {
    "id": "declaration/130/tail/arm/13",
    "outcome": "DecimalExpr",
    "line": 2067,
    "state": "covered",
    "hits": "11"
  },
  {
    "id": "declaration/130/tail/arm/14",
    "outcome": "StringExpr",
    "line": 2067,
    "state": "covered",
    "hits": "5016"
  },
  {
    "id": "declaration/130/tail/arm/15",
    "outcome": "BoolExpr",
    "line": 2068,
    "state": "covered",
    "hits": "1119"
  },
  {
    "id": "declaration/130/tail/arm/16",
    "outcome": "NameExpr",
    "line": 2068,
    "state": "covered",
    "hits": "27368"
  },
  {
    "id": "declaration/131/statement/2/decision/body",
    "outcome": "body",
    "line": 2075,
    "state": "covered",
    "hits": "10436"
  },
  {
    "id": "declaration/131/statement/2/decision/exit",
    "outcome": "exit",
    "line": 2075,
    "state": "covered",
    "hits": "11279"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/0",
    "outcome": "BindingStatement",
    "line": 2077,
    "state": "covered",
    "hits": "3709"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/0/body/block/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2078,
    "state": "covered",
    "hits": "3709"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/0/body/block/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2078,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/0/body/block/statement/0/value/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2078,
    "state": "covered",
    "hits": "3709"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/0/body/block/statement/0/value/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 2078,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/0/body/block/tail/decision/true",
    "outcome": "true",
    "line": 2079,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/0/body/block/tail/decision/false",
    "outcome": "false",
    "line": 2079,
    "state": "covered",
    "hits": "3707"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/1",
    "outcome": "AssignmentStatement",
    "line": 2081,
    "state": "covered",
    "hits": "4423"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/1/body/block/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2082,
    "state": "covered",
    "hits": "4423"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/1/body/block/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2082,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/1/body/block/tail/decision/true",
    "outcome": "true",
    "line": 2083,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/1/body/block/tail/decision/false",
    "outcome": "false",
    "line": 2083,
    "state": "covered",
    "hits": "4421"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/2",
    "outcome": "ExpressionStatement",
    "line": 2085,
    "state": "covered",
    "hits": "1298"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/2/body/block/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2085,
    "state": "covered",
    "hits": "1298"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/2/body/block/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2085,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/3",
    "outcome": "WhileStatement",
    "line": 2086,
    "state": "covered",
    "hits": "264"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/3/body/block/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2086,
    "state": "covered",
    "hits": "264"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/3/body/block/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2086,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/3/body/block/statement/0/value/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2086,
    "state": "covered",
    "hits": "264"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/3/body/block/statement/0/value/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 2086,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/4",
    "outcome": "ForStatement",
    "line": 2087,
    "state": "covered",
    "hits": "742"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/4/body/block/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2087,
    "state": "covered",
    "hits": "742"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/4/body/block/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2087,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/4/body/block/statement/0/value/left/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2087,
    "state": "covered",
    "hits": "742"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/4/body/block/statement/0/value/left/decision/skip-right",
    "outcome": "skip-right",
    "line": 2087,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/4/body/block/statement/0/value/right/args/2/decision/true",
    "outcome": "true",
    "line": 2087,
    "state": "covered",
    "hits": "2"
  },
  {
    "id": "declaration/131/statement/2/body/tail/arm/4/body/block/statement/0/value/right/args/2/decision/false",
    "outcome": "false",
    "line": 2087,
    "state": "covered",
    "hits": "740"
  },
  {
    "id": "declaration/131/tail/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2090,
    "state": "covered",
    "hits": "11279"
  },
  {
    "id": "declaration/131/tail/decision/skip-right",
    "outcome": "skip-right",
    "line": 2090,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/131/tail/right/arm/0",
    "outcome": "NoBlockValue",
    "line": 2091,
    "state": "covered",
    "hits": "5322"
  },
  {
    "id": "declaration/131/tail/right/arm/1",
    "outcome": "TailBlockValue",
    "line": 2092,
    "state": "covered",
    "hits": "5957"
  },
  {
    "id": "declaration/132/tail/arm/0",
    "outcome": "ImportDeclaration",
    "line": 2098,
    "state": "covered",
    "hits": "173"
  },
  {
    "id": "declaration/132/tail/arm/1",
    "outcome": "TypeDeclaration",
    "line": 2099,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/132/tail/arm/1/body/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2099,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/132/tail/arm/1/body/decision/skip-right",
    "outcome": "skip-right",
    "line": 2099,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/132/tail/arm/1/body/right/args/2/decision/true",
    "outcome": "true",
    "line": 2099,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/132/tail/arm/1/body/right/args/2/decision/false",
    "outcome": "false",
    "line": 2099,
    "state": "covered",
    "hits": "32"
  },
  {
    "id": "declaration/132/tail/arm/2",
    "outcome": "RecordDeclaration",
    "line": 2100,
    "state": "covered",
    "hits": "378"
  },
  {
    "id": "declaration/132/tail/arm/2/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 2102,
    "state": "covered",
    "hits": "1030"
  },
  {
    "id": "declaration/132/tail/arm/2/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2102,
    "state": "covered",
    "hits": "378"
  },
  {
    "id": "declaration/132/tail/arm/2/body/block/statement/1/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2102,
    "state": "covered",
    "hits": "1030"
  },
  {
    "id": "declaration/132/tail/arm/2/body/block/statement/1/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2102,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/132/tail/arm/3",
    "outcome": "EnumDeclaration",
    "line": 2105,
    "state": "covered",
    "hits": "386"
  },
  {
    "id": "declaration/132/tail/arm/3/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 2107,
    "state": "covered",
    "hits": "1009"
  },
  {
    "id": "declaration/132/tail/arm/3/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2107,
    "state": "covered",
    "hits": "386"
  },
  {
    "id": "declaration/132/tail/arm/3/body/block/statement/1/body/statement/0/decision/body",
    "outcome": "body",
    "line": 2107,
    "state": "covered",
    "hits": "569"
  },
  {
    "id": "declaration/132/tail/arm/3/body/block/statement/1/body/statement/0/decision/exit",
    "outcome": "exit",
    "line": 2107,
    "state": "covered",
    "hits": "1009"
  },
  {
    "id": "declaration/132/tail/arm/3/body/block/statement/1/body/statement/0/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2107,
    "state": "covered",
    "hits": "569"
  },
  {
    "id": "declaration/132/tail/arm/3/body/block/statement/1/body/statement/0/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2107,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/132/tail/arm/4",
    "outcome": "FunctionDeclaration",
    "line": 2110,
    "state": "covered",
    "hits": "1966"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/1/decision/body",
    "outcome": "body",
    "line": 2112,
    "state": "covered",
    "hits": "2803"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/1/decision/exit",
    "outcome": "exit",
    "line": 2112,
    "state": "covered",
    "hits": "1966"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/1/body/tail/decision/true",
    "outcome": "true",
    "line": 2112,
    "state": "covered",
    "hits": "3"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/1/body/tail/decision/false",
    "outcome": "false",
    "line": 2112,
    "state": "covered",
    "hits": "2800"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/2/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2113,
    "state": "covered",
    "hits": "1966"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/2/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2113,
    "state": "zero",
    "hits": "0"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/3/decision/body",
    "outcome": "body",
    "line": 2114,
    "state": "covered",
    "hits": "2803"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/3/decision/exit",
    "outcome": "exit",
    "line": 2114,
    "state": "covered",
    "hits": "1966"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/3/body/statement/0/value/decision/evaluate-right",
    "outcome": "evaluate-right",
    "line": 2114,
    "state": "covered",
    "hits": "2803"
  },
  {
    "id": "declaration/132/tail/arm/4/body/block/statement/3/body/statement/0/value/decision/skip-right",
    "outcome": "skip-right",
    "line": 2114,
    "state": "zero",
    "hits": "0"
  }
]

Reviewed declaration exclusions

[
  {
    "id": "declaration/0",
    "reason": "import",
    "line": 1
  },
  {
    "id": "declaration/1",
    "reason": "enum-declaration",
    "line": 3
  },
  {
    "id": "declaration/3",
    "reason": "record-declaration",
    "line": 38
  },
  {
    "id": "declaration/4",
    "reason": "record-declaration",
    "line": 43
  },
  {
    "id": "declaration/5",
    "reason": "enum-declaration",
    "line": 48
  },
  {
    "id": "declaration/6",
    "reason": "record-declaration",
    "line": 57
  },
  {
    "id": "declaration/7",
    "reason": "record-declaration",
    "line": 62
  },
  {
    "id": "declaration/8",
    "reason": "record-declaration",
    "line": 67
  },
  {
    "id": "declaration/9",
    "reason": "record-declaration",
    "line": 72
  },
  {
    "id": "declaration/10",
    "reason": "record-declaration",
    "line": 78
  },
  {
    "id": "declaration/12",
    "reason": "enum-declaration",
    "line": 117
  },
  {
    "id": "declaration/13",
    "reason": "enum-declaration",
    "line": 127
  },
  {
    "id": "declaration/14",
    "reason": "record-declaration",
    "line": 132
  },
  {
    "id": "declaration/15",
    "reason": "record-declaration",
    "line": 137
  },
  {
    "id": "declaration/16",
    "reason": "record-declaration",
    "line": 142
  },
  {
    "id": "declaration/17",
    "reason": "record-declaration",
    "line": 147
  },
  {
    "id": "declaration/18",
    "reason": "record-declaration",
    "line": 152
  },
  {
    "id": "declaration/19",
    "reason": "record-declaration",
    "line": 157
  },
  {
    "id": "declaration/20",
    "reason": "record-declaration",
    "line": 162
  },
  {
    "id": "declaration/21",
    "reason": "record-declaration",
    "line": 167
  },
  {
    "id": "declaration/22",
    "reason": "record-declaration",
    "line": 172
  },
  {
    "id": "declaration/23",
    "reason": "record-declaration",
    "line": 177
  },
  {
    "id": "declaration/28",
    "reason": "record-declaration",
    "line": 216
  },
  {
    "id": "declaration/87",
    "reason": "record-declaration",
    "line": 1407
  },
  {
    "id": "declaration/88",
    "reason": "enum-declaration",
    "line": 1413
  },
  {
    "id": "declaration/89",
    "reason": "record-declaration",
    "line": 1419
  },
  {
    "id": "declaration/90",
    "reason": "record-declaration",
    "line": 1425
  },
  {
    "id": "declaration/91",
    "reason": "record-declaration",
    "line": 1430
  }
]