|  line  | 
 true  | 
 false  | 
 branch  | 
 
| 
738
 | 
 0  | 
 0  | 
     assert(parser); /* Non-NULL parser object is expected. */  | 
 
| 
739
 | 
 0  | 
 0  | 
     assert(token);  /* Non-NULL token object is expected. */  | 
 
| 
747
 | 
 0  | 
 0  | 
     if (parser->stream_end_produced  | 
 
| 
748
 | 
 0  | 
 0  | 
         || (parser->error  | 
 
| 
750
 | 
 0  | 
 0  | 
             && (!parser->problem_nonstrict || parser->error != YAML_READER_ERROR)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (!parser->problem_nonstrict || parser->error != YAML_READER_ERROR)))  | 
 
| 
755
 | 
 0  | 
 0  | 
     if (!parser->token_available) {  | 
 
| 
756
 | 
 0  | 
 0  | 
         if (!yaml_parser_fetch_more_tokens(parser))  | 
 
| 
766
 | 
 0  | 
 0  | 
     if (token->type == YAML_STREAM_END_TOKEN) {  | 
 
| 
810
 | 
 836  | 
 1599  | 
         if (parser->tokens.head == parser->tokens.tail)  | 
 
| 
822
 | 
 0  | 
 1599  | 
             if (!yaml_parser_stale_simple_keys(parser))  | 
 
| 
825
 | 
 1678  | 
 1375  | 
             for (simple_key = parser->simple_keys.start;  | 
 
| 
827
 | 
 243  | 
 1435  | 
                 if (simple_key->possible  | 
 
| 
828
 | 
 224  | 
 19  | 
                         && simple_key->token_number == parser->tokens_parsed) {  | 
 
| 
837
 | 
 1375  | 
 1060  | 
         if (!need_more_tokens)  | 
 
| 
842
 | 
 5  | 
 1055  | 
         if (!yaml_parser_fetch_next_token(parser))  | 
 
| 
860
 | 
 109  | 
 951  | 
     if (!CACHE(parser, 1))  | 
 
| 
 | 
 1  | 
 108  | 
     if (!CACHE(parser, 1))  | 
 
| 
865
 | 
 108  | 
 951  | 
     if (!parser->stream_start_produced)  | 
 
| 
870
 | 
 0  | 
 951  | 
     if (!yaml_parser_scan_to_next_token(parser))  | 
 
| 
875
 | 
 0  | 
 951  | 
     if (!yaml_parser_stale_simple_keys(parser))  | 
 
| 
880
 | 
 0  | 
 951  | 
     if (!yaml_parser_unroll_indent(parser, parser->mark.column))  | 
 
| 
888
 | 
 135  | 
 816  | 
     if (!CACHE(parser, 4))  | 
 
| 
 | 
 0  | 
 135  | 
     if (!CACHE(parser, 4))  | 
 
| 
893
 | 
 101  | 
 850  | 
     if (IS_Z(parser->buffer))  | 
 
| 
898
 | 
 289  | 
 561  | 
     if (parser->mark.column == 0 && CHECK(parser->buffer, '%'))  | 
 
| 
 | 
 0  | 
 289  | 
     if (parser->mark.column == 0 && CHECK(parser->buffer, '%'))  | 
 
| 
903
 | 
 289  | 
 561  | 
     if (parser->mark.column == 0  | 
 
| 
904
 | 
 191  | 
 98  | 
             && CHECK_AT(parser->buffer, '-', 0)  | 
 
| 
905
 | 
 97  | 
 94  | 
             && CHECK_AT(parser->buffer, '-', 1)  | 
 
| 
906
 | 
 97  | 
 0  | 
             && CHECK_AT(parser->buffer, '-', 2)  | 
 
| 
907
 | 
 44  | 
 53  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 44  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 44  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 44  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
913
 | 
 192  | 
 561  | 
     if (parser->mark.column == 0  | 
 
| 
914
 | 
 0  | 
 192  | 
             && CHECK_AT(parser->buffer, '.', 0)  | 
 
| 
915
 | 
 0  | 
 0  | 
             && CHECK_AT(parser->buffer, '.', 1)  | 
 
| 
916
 | 
 0  | 
 0  | 
             && CHECK_AT(parser->buffer, '.', 2)  | 
 
| 
917
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             && IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
923
 | 
 12  | 
 741  | 
     if (CHECK(parser->buffer, '['))  | 
 
| 
929
 | 
 14  | 
 727  | 
     if (CHECK(parser->buffer, '{'))  | 
 
| 
935
 | 
 12  | 
 715  | 
     if (CHECK(parser->buffer, ']'))  | 
 
| 
941
 | 
 14  | 
 701  | 
     if (CHECK(parser->buffer, '}'))  | 
 
| 
947
 | 
 8  | 
 693  | 
     if (CHECK(parser->buffer, ','))  | 
 
| 
952
 | 
 113  | 
 580  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 4  | 
 109  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 4  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 4  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 4  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
957
 | 
 0  | 
 580  | 
     if (CHECK(parser->buffer, '?')  | 
 
| 
958
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
963
 | 
 126  | 
 454  | 
     if (CHECK(parser->buffer, ':')  | 
 
| 
964
 | 
 116  | 
 10  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 11  | 
 105  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 11  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 11  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 11  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
             && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
969
 | 
 19  | 
 435  | 
     if (CHECK(parser->buffer, '*'))  | 
 
| 
974
 | 
 17  | 
 418  | 
     if (CHECK(parser->buffer, '&'))  | 
 
| 
979
 | 
 82  | 
 336  | 
     if (CHECK(parser->buffer, '!'))  | 
 
| 
984
 | 
 7  | 
 329  | 
     if (CHECK(parser->buffer, '|') && !parser->flow_level)  | 
 
| 
 | 
 7  | 
 0  | 
     if (CHECK(parser->buffer, '|') && !parser->flow_level)  | 
 
| 
989
 | 
 0  | 
 329  | 
     if (CHECK(parser->buffer, '>') && !parser->flow_level)  | 
 
| 
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '>') && !parser->flow_level)  | 
 
| 
994
 | 
 16  | 
 313  | 
     if (CHECK(parser->buffer, '\''))  | 
 
| 
999
 | 
 11  | 
 302  | 
     if (CHECK(parser->buffer, '"'))  | 
 
| 
1021
 | 
 302  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 302  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 302  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 302  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 302  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 302  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 302  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 302  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 302  | 
 0  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
 | 
 0  | 
 302  | 
     if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')  | 
 
| 
1022
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')  | 
 
| 
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')  | 
 
| 
1023
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[')  | 
 
| 
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[')  | 
 
| 
1024
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')  | 
 
| 
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')  | 
 
| 
1025
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#')  | 
 
| 
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#')  | 
 
| 
1026
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*')  | 
 
| 
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*')  | 
 
| 
1027
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|')  | 
 
| 
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|')  | 
 
| 
1028
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'')  | 
 
| 
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'')  | 
 
| 
1029
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%')  | 
 
| 
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%')  | 
 
| 
1030
 | 
 302  | 
 0  | 
                 || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) ||  | 
 
| 
 | 
 0  | 
 0  | 
                 || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) ||  | 
 
| 
1031
 | 
 0  | 
 0  | 
             (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) ||  | 
 
| 
 | 
 0  | 
 0  | 
             (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) ||  | 
 
| 
 | 
 0  | 
 0  | 
             (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) ||  | 
 
| 
1032
 | 
 0  | 
 0  | 
             (!parser->flow_level &&  | 
 
| 
1033
 | 
 0  | 
 0  | 
              (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':'))  | 
 
| 
1034
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
 | 
 0  | 
 0  | 
              && !IS_BLANKZ_AT(parser->buffer, 1)))  | 
 
| 
1058
 | 
 2744  | 
 2550  | 
     for (simple_key = parser->simple_keys.start;  | 
 
| 
1068
 | 
 556  | 
 2188  | 
         if (simple_key->possible  | 
 
| 
1069
 | 
 458  | 
 98  | 
                 && (simple_key->mark.line < parser->mark.line  | 
 
| 
1070
 | 
 0  | 
 458  | 
                     || simple_key->mark.index+1024 < parser->mark.index)) {  | 
 
| 
1074
 | 
 0  | 
 98  | 
             if (simple_key->required) {  | 
 
| 
1102
 | 
 438  | 
 35  | 
             && parser->indent == (ptrdiff_t)parser->mark.column);  | 
 
| 
 | 
 54  | 
 384  | 
             && parser->indent == (ptrdiff_t)parser->mark.column);  | 
 
| 
1108
 | 
 248  | 
 225  | 
     if (parser->simple_key_allowed)  | 
 
| 
1117
 | 
 0  | 
 248  | 
         if (!yaml_parser_remove_simple_key(parser)) return 0;  | 
 
| 
1134
 | 
 24  | 
 576  | 
     if (simple_key->possible)  | 
 
| 
1138
 | 
 0  | 
 24  | 
         if (simple_key->required) {  | 
 
| 
1163
 | 
 0  | 
 26  | 
     if (!PUSH(parser, parser->simple_keys, empty_simple_key))  | 
 
| 
 | 
 0  | 
 0  | 
     if (!PUSH(parser, parser->simple_keys, empty_simple_key))  | 
 
| 
 | 
 0  | 
 26  | 
     if (!PUSH(parser, parser->simple_keys, empty_simple_key))  | 
 
| 
1168
 | 
 0  | 
 26  | 
     if (parser->flow_level == INT_MAX) {  | 
 
| 
1185
 | 
 26  | 
 0  | 
     if (parser->flow_level) {  | 
 
| 
1208
 | 
 10  | 
 228  | 
     if (parser->flow_level)  | 
 
| 
1211
 | 
 99  | 
 129  | 
     if (parser->indent < column)  | 
 
| 
1218
 | 
 0  | 
 99  | 
         if (!PUSH(parser, parser->indents, parser->indent))  | 
 
| 
 | 
 0  | 
 0  | 
         if (!PUSH(parser, parser->indents, parser->indent))  | 
 
| 
 | 
 0  | 
 99  | 
         if (!PUSH(parser, parser->indents, parser->indent))  | 
 
| 
1221
 | 
 0  | 
 99  | 
         if (column > INT_MAX) {  | 
 
| 
1232
 | 
 37  | 
 62  | 
         if (number == -1) {  | 
 
| 
1233
 | 
 0  | 
 37  | 
             if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 0  | 
             if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 37  | 
             if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1237
 | 
 0  | 
 62  | 
             if (!QUEUE_INSERT(parser,  | 
 
| 
 | 
 0  | 
 0  | 
             if (!QUEUE_INSERT(parser,  | 
 
| 
 | 
 0  | 
 62  | 
             if (!QUEUE_INSERT(parser,  | 
 
| 
1260
 | 
 79  | 
 1070  | 
     if (parser->flow_level)  | 
 
| 
1265
 | 
 96  | 
 1070  | 
     while (parser->indent > column)  | 
 
| 
1271
 | 
 8  | 
 88  | 
         if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 8  | 
 0  | 
         if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 96  | 
         if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1298
 | 
 0  | 
 108  | 
     if (!PUSH(parser, parser->simple_keys, simple_key))  | 
 
| 
 | 
 0  | 
 0  | 
     if (!PUSH(parser, parser->simple_keys, simple_key))  | 
 
| 
 | 
 0  | 
 108  | 
     if (!PUSH(parser, parser->simple_keys, simple_key))  | 
 
| 
1314
 | 
 0  | 
 108  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 108  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1331
 | 
 5  | 
 96  | 
     if (parser->mark.column != 0) {  | 
 
| 
1338
 | 
 0  | 
 101  | 
     if (!yaml_parser_unroll_indent(parser, -1))  | 
 
| 
1343
 | 
 0  | 
 101  | 
     if (!yaml_parser_remove_simple_key(parser))  | 
 
| 
1352
 | 
 2  | 
 99  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 2  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 101  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1369
 | 
 0  | 
 0  | 
     if (!yaml_parser_unroll_indent(parser, -1))  | 
 
| 
1374
 | 
 0  | 
 0  | 
     if (!yaml_parser_remove_simple_key(parser))  | 
 
| 
1381
 | 
 0  | 
 0  | 
     if (!yaml_parser_scan_directive(parser, &token))  | 
 
| 
1386
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
1407
 | 
 0  | 
 97  | 
     if (!yaml_parser_unroll_indent(parser, -1))  | 
 
| 
1412
 | 
 0  | 
 97  | 
     if (!yaml_parser_remove_simple_key(parser))  | 
 
| 
1421
 | 
 0  | 
 97  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1422
 | 
 0  | 
 97  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1423
 | 
 0  | 
 97  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1433
 | 
 0  | 
 97  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 97  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1452
 | 
 0  | 
 26  | 
     if (!yaml_parser_save_simple_key(parser))  | 
 
| 
1457
 | 
 0  | 
 26  | 
     if (!yaml_parser_increase_flow_level(parser))  | 
 
| 
1467
 | 
 0  | 
 26  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1476
 | 
 1  | 
 25  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 1  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 26  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1495
 | 
 0  | 
 26  | 
     if (!yaml_parser_remove_simple_key(parser))  | 
 
| 
1500
 | 
 0  | 
 26  | 
     if (!yaml_parser_decrease_flow_level(parser))  | 
 
| 
1510
 | 
 0  | 
 26  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1519
 | 
 1  | 
 25  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 1  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 26  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1537
 | 
 0  | 
 8  | 
     if (!yaml_parser_remove_simple_key(parser))  | 
 
| 
1547
 | 
 0  | 
 8  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1554
 | 
 1  | 
 7  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 1  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 8  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1572
 | 
 113  | 
 0  | 
     if (!parser->flow_level)  | 
 
| 
1576
 | 
 0  | 
 113  | 
         if (!parser->simple_key_allowed) {  | 
 
| 
1583
 | 
 0  | 
 113  | 
         if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,  | 
 
| 
1598
 | 
 0  | 
 113  | 
     if (!yaml_parser_remove_simple_key(parser))  | 
 
| 
1608
 | 
 0  | 
 113  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1615
 | 
 2  | 
 111  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 2  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 113  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1633
 | 
 0  | 
 0  | 
     if (!parser->flow_level)  | 
 
| 
1637
 | 
 0  | 
 0  | 
         if (!parser->simple_key_allowed) {  | 
 
| 
1644
 | 
 0  | 
 0  | 
         if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,  | 
 
| 
1651
 | 
 0  | 
 0  | 
     if (!yaml_parser_remove_simple_key(parser))  | 
 
| 
1661
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1668
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1687
 | 
 125  | 
 1  | 
     if (simple_key->possible)  | 
 
| 
1694
 | 
 8  | 
 117  | 
         if (!QUEUE_INSERT(parser, parser->tokens,  | 
 
| 
 | 
 8  | 
 0  | 
         if (!QUEUE_INSERT(parser, parser->tokens,  | 
 
| 
 | 
 0  | 
 125  | 
         if (!QUEUE_INSERT(parser, parser->tokens,  | 
 
| 
1700
 | 
 0  | 
 125  | 
         if (!yaml_parser_roll_indent(parser, simple_key->mark.column,  | 
 
| 
1719
 | 
 1  | 
 0  | 
         if (!parser->flow_level)  | 
 
| 
1723
 | 
 1  | 
 0  | 
             if (!parser->simple_key_allowed) {  | 
 
| 
1730
 | 
 0  | 
 0  | 
             if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,  | 
 
| 
1743
 | 
 0  | 
 125  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
1750
 | 
 5  | 
 120  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 5  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
 | 
 0  | 
 125  | 
     if (!ENQUEUE(parser, parser->tokens, token))  | 
 
| 
1767
 | 
 0  | 
 36  | 
     if (!yaml_parser_save_simple_key(parser))  | 
 
| 
1776
 | 
 3  | 
 33  | 
     if (!yaml_parser_scan_anchor(parser, &token, type))  | 
 
| 
1779
 | 
 1  | 
 32  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 1  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 33  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
1797
 | 
 0  | 
 82  | 
     if (!yaml_parser_save_simple_key(parser))  | 
 
| 
1806
 | 
 0  | 
 82  | 
     if (!yaml_parser_scan_tag(parser, &token))  | 
 
| 
1809
 | 
 0  | 
 82  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 82  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
1828
 | 
 0  | 
 7  | 
     if (!yaml_parser_remove_simple_key(parser))  | 
 
| 
1837
 | 
 0  | 
 7  | 
     if (!yaml_parser_scan_block_scalar(parser, &token, literal))  | 
 
| 
1840
 | 
 0  | 
 7  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 7  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
1859
 | 
 0  | 
 27  | 
     if (!yaml_parser_save_simple_key(parser))  | 
 
| 
1868
 | 
 0  | 
 27  | 
     if (!yaml_parser_scan_flow_scalar(parser, &token, single))  | 
 
| 
1871
 | 
 1  | 
 26  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 1  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 27  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
1890
 | 
 0  | 
 302  | 
     if (!yaml_parser_save_simple_key(parser))  | 
 
| 
1899
 | 
 0  | 
 302  | 
     if (!yaml_parser_scan_plain_scalar(parser, &token))  | 
 
| 
1902
 | 
 11  | 
 291  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 11  | 
 0  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
 | 
 0  | 
 302  | 
     if (!ENQUEUE(parser, parser->tokens, token)) {  | 
 
| 
1923
 | 
 0  | 
 1114  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
1925
 | 
 417  | 
 697  | 
         if (parser->mark.column == 0 && IS_BOM(parser->buffer))  | 
 
| 
 | 
 0  | 
 417  | 
         if (parser->mark.column == 0 && IS_BOM(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         if (parser->mark.column == 0 && IS_BOM(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         if (parser->mark.column == 0 && IS_BOM(parser->buffer))  | 
 
| 
1926
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
1938
 | 
 0  | 
 1114  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
1940
 | 
 477  | 
 1114  | 
         while (CHECK(parser->buffer,' ') ||  | 
 
| 
 | 
 1033  | 
 81  | 
         while (CHECK(parser->buffer,' ') ||  | 
 
| 
1941
 | 
 491  | 
 542  | 
                 ((parser->flow_level || !parser->simple_key_allowed) &&  | 
 
| 
 | 
 0  | 
 572  | 
                 ((parser->flow_level || !parser->simple_key_allowed) &&  | 
 
| 
1943
 | 
 0  | 
 477  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
1944
 | 
 0  | 
 477  | 
             if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) return 0;  | 
 
| 
1949
 | 
 2  | 
 1112  | 
         if (CHECK(parser->buffer, '#')) {  | 
 
| 
1950
 | 
 54  | 
 0  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 52  | 
 2  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 52  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 52  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 52  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 52  | 
 0  | 
             while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
1951
 | 
 0  | 
 52  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
1952
 | 
 0  | 
 52  | 
                 if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!CACHE(parser, 1)) return 0;  | 
 
| 
1958
 | 
 1114  | 
 0  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 951  | 
 163  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 951  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 951  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 951  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         if (IS_BREAK(parser->buffer))  | 
 
| 
1960
 | 
 17  | 
 146  | 
             if (!CACHE(parser, 2)) return 0;  | 
 
| 
 | 
 0  | 
 17  | 
             if (!CACHE(parser, 2)) return 0;  | 
 
| 
1961
 | 
 0  | 
 163  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 163  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 163  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 163  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP_LINE(parser);  | 
 
| 
1965
 | 
 161  | 
 2  | 
             if (!parser->flow_level) {  | 
 
| 
2002
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
2006
 | 
 0  | 
 0  | 
     if (!yaml_parser_scan_directive_name(parser, start_mark, &name))  | 
 
| 
2011
 | 
 0  | 
 0  | 
     if (strcmp((char *)name, "YAML") == 0)  | 
 
| 
2015
 | 
 0  | 
 0  | 
         if (!yaml_parser_scan_version_directive_value(parser, start_mark,  | 
 
| 
2029
 | 
 0  | 
 0  | 
     else if (strcmp((char *)name, "TAG") == 0)  | 
 
| 
2033
 | 
 0  | 
 0  | 
         if (!yaml_parser_scan_tag_directive_value(parser, start_mark,  | 
 
| 
2056
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2058
 | 
 0  | 
 0  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
2059
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2060
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2063
 | 
 0  | 
 0  | 
     if (CHECK(parser->buffer, '#')) {  | 
 
| 
2064
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
2065
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
2066
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
2072
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
2080
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
2081
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 2)) goto error;  | 
 
| 
2082
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
2112
 | 
 0  | 
 0  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
2116
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2118
 | 
 0  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
2120
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
2121
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2126
 | 
 0  | 
 0  | 
     if (string.start == string.pointer) {  | 
 
| 
2134
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
2163
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) return 0;  | 
 
| 
2165
 | 
 0  | 
 0  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
2166
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2167
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
2172
 | 
 0  | 
 0  | 
     if (!yaml_parser_scan_version_directive_number(parser, start_mark, major))  | 
 
| 
2177
 | 
 0  | 
 0  | 
     if (!CHECK(parser->buffer, '.')) {  | 
 
| 
2182
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
2186
 | 
 0  | 
 0  | 
     if (!yaml_parser_scan_version_directive_number(parser, start_mark, minor))  | 
 
| 
2213
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) return 0;  | 
 
| 
2215
 | 
 0  | 
 0  | 
     while (IS_DIGIT(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_DIGIT(parser->buffer))  | 
 
| 
2219
 | 
 0  | 
 0  | 
         if (++length > MAX_NUMBER_LENGTH) {  | 
 
| 
2226
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2228
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
2233
 | 
 0  | 
 0  | 
     if (!length) {  | 
 
| 
2260
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2262
 | 
 0  | 
 0  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
2263
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2264
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2269
 | 
 0  | 
 0  | 
     if (!yaml_parser_scan_tag_handle(parser, 1, start_mark, &handle_value))  | 
 
| 
2274
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2276
 | 
 0  | 
 0  | 
     if (!IS_BLANK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANK(parser->buffer)) {  | 
 
| 
2284
 | 
 0  | 
 0  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
2285
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2286
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2291
 | 
 0  | 
 0  | 
     if (!yaml_parser_scan_tag_uri(parser, 1, NULL, start_mark, &prefix_value))  | 
 
| 
2296
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2298
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
2323
 | 
 36  | 
 0  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 36  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
2329
 | 
 0  | 
 36  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
2333
 | 
 0  | 
 36  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2335
 | 
 95  | 
 34  | 
     while (IS_ALPHA(parser->buffer)) {  | 
 
| 
 | 
 15  | 
 80  | 
     while (IS_ALPHA(parser->buffer)) {  | 
 
| 
 | 
 79  | 
 35  | 
     while (IS_ALPHA(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 79  | 
     while (IS_ALPHA(parser->buffer)) {  | 
 
| 
 | 
 78  | 
 36  | 
     while (IS_ALPHA(parser->buffer)) {  | 
 
| 
 | 
 78  | 
 0  | 
     while (IS_ALPHA(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 36  | 
     while (IS_ALPHA(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 36  | 
     while (IS_ALPHA(parser->buffer)) {  | 
 
| 
2336
 | 
 0  | 
 93  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 93  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 93  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 93  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
2337
 | 
 0  | 
 93  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2350
 | 
 33  | 
 3  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 19  | 
 14  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 19  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 19  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 2  | 
 17  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 2  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 2  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 2  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 2  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 2  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 0  | 
     if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')  | 
 
| 
2351
 | 
 2  | 
 0  | 
                 || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',')  | 
 
| 
 | 
 1  | 
 1  | 
                 || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',')  | 
 
| 
2352
 | 
 0  | 
 1  | 
                 || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}')  | 
 
| 
 | 
 0  | 
 0  | 
                 || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}')  | 
 
| 
2353
 | 
 0  | 
 0  | 
                 || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@')  | 
 
| 
 | 
 0  | 
 0  | 
                 || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@')  | 
 
| 
2355
 | 
 0  | 
 3  | 
         yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ?  | 
 
| 
2363
 | 
 17  | 
 16  | 
     if (type == YAML_ANCHOR_TOKEN) {  | 
 
| 
2392
 | 
 0  | 
 82  | 
     if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 2)) goto error;  | 
 
| 
2394
 | 
 2  | 
 80  | 
     if (CHECK_AT(parser->buffer, '<', 1))  | 
 
| 
2399
 | 
 0  | 
 2  | 
         if (!handle) goto error;  | 
 
| 
2404
 | 
 0  | 
 2  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2405
 | 
 0  | 
 2  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2409
 | 
 0  | 
 2  | 
         if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix))  | 
 
| 
2414
 | 
 0  | 
 2  | 
         if (!CHECK(parser->buffer, '>')) {  | 
 
| 
2420
 | 
 0  | 
 2  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2428
 | 
 0  | 
 80  | 
         if (!yaml_parser_scan_tag_handle(parser, 0, start_mark, &handle))  | 
 
| 
2433
 | 
 80  | 
 0  | 
         if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!')  | 
 
| 
 | 
 80  | 
 0  | 
         if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!')  | 
 
| 
 | 
 71  | 
 9  | 
         if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!')  | 
 
| 
2437
 | 
 0  | 
 71  | 
             if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix))  | 
 
| 
2444
 | 
 0  | 
 9  | 
             if (!yaml_parser_scan_tag_uri(parser, 0, handle, start_mark, &suffix))  | 
 
| 
2451
 | 
 0  | 
 9  | 
             if (!handle) goto error;  | 
 
| 
2460
 | 
 0  | 
 9  | 
             if (suffix[0] == '\0') {  | 
 
| 
2470
 | 
 0  | 
 82  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2472
 | 
 32  | 
 50  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 32  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 32  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 32  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BLANKZ(parser->buffer)) {  | 
 
| 
2502
 | 
 80  | 
 0  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 80  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
2506
 | 
 0  | 
 80  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2508
 | 
 0  | 
 80  | 
     if (!CHECK(parser->buffer, '!')) {  | 
 
| 
2509
 | 
 0  | 
 0  | 
         yaml_parser_set_scanner_error(parser, directive ?  | 
 
| 
2517
 | 
 0  | 
 80  | 
     if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 80  | 
 0  | 
     if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 80  | 
 0  | 
     if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 80  | 
     if (!READ(parser, string)) goto error;  | 
 
| 
2521
 | 
 0  | 
 80  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2523
 | 
 35  | 
 73  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 35  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 28  | 
 80  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 7  | 
 21  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 21  | 
 80  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 21  | 
 0  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 80  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
 | 
 0  | 
 80  | 
     while (IS_ALPHA(parser->buffer))  | 
 
| 
2525
 | 
 0  | 
 28  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 28  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 28  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 28  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
2526
 | 
 0  | 
 28  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2531
 | 
 71  | 
 9  | 
     if (CHECK(parser->buffer, '!'))  | 
 
| 
2533
 | 
 0  | 
 71  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 71  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 71  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 71  | 
         if (!READ(parser, string)) goto error;  | 
 
| 
2543
 | 
 0  | 
 9  | 
         if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) {  | 
 
| 
 | 
 0  | 
 0  | 
         if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) {  | 
 
| 
 | 
 0  | 
 0  | 
         if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) {  | 
 
| 
2567
 | 
 9  | 
 73  | 
     size_t length = head ? strlen((char *)head) : 0;  | 
 
| 
2570
 | 
 82  | 
 0  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 82  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
2574
 | 
 0  | 
 82  | 
     while ((size_t)(string.end - string.start) <= length) {  | 
 
| 
2575
 | 
 0  | 
 0  | 
         if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) {  | 
 
| 
2587
 | 
 9  | 
 73  | 
     if (length > 1) {  | 
 
| 
2594
 | 
 0  | 
 82  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2604
 | 
 883  | 
 142  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
 | 
 8  | 
 875  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
 | 
 782  | 
 235  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
 | 
 60  | 
 722  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
 | 
 722  | 
 235  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
 | 
 722  | 
 0  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
 | 
 0  | 
 235  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
 | 
 0  | 
 235  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
 | 
 0  | 
 235  | 
     while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')  | 
 
| 
2605
 | 
 57  | 
 178  | 
             || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?')  | 
 
| 
 | 
 0  | 
 178  | 
             || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?')  | 
 
| 
2606
 | 
 91  | 
 87  | 
             || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@')  | 
 
| 
 | 
 0  | 
 87  | 
             || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@')  | 
 
| 
2607
 | 
 0  | 
 87  | 
             || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=')  | 
 
| 
 | 
 0  | 
 87  | 
             || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=')  | 
 
| 
2608
 | 
 0  | 
 87  | 
             || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$')  | 
 
| 
 | 
 0  | 
 87  | 
             || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$')  | 
 
| 
2609
 | 
 2  | 
 85  | 
             || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '.')  | 
 
| 
 | 
 2  | 
 83  | 
             || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '.')  | 
 
| 
2610
 | 
 1  | 
 82  | 
             || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~')  | 
 
| 
 | 
 0  | 
 82  | 
             || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~')  | 
 
| 
2611
 | 
 0  | 
 82  | 
             || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'')  | 
 
| 
 | 
 0  | 
 82  | 
             || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'')  | 
 
| 
2612
 | 
 0  | 
 82  | 
             || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')')  | 
 
| 
 | 
 0  | 
 82  | 
             || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')')  | 
 
| 
2613
 | 
 0  | 
 82  | 
             || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']')  | 
 
| 
 | 
 0  | 
 82  | 
             || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']')  | 
 
| 
2614
 | 
 0  | 
 82  | 
             || CHECK(parser->buffer, '%'))  | 
 
| 
2618
 | 
 0  | 
 943  | 
         if (CHECK(parser->buffer, '%')) {  | 
 
| 
2619
 | 
 0  | 
 0  | 
             if (!STRING_EXTEND(parser, string))  | 
 
| 
 | 
 0  | 
 0  | 
             if (!STRING_EXTEND(parser, string))  | 
 
| 
 | 
 0  | 
 0  | 
             if (!STRING_EXTEND(parser, string))  | 
 
| 
2622
 | 
 0  | 
 0  | 
             if (!yaml_parser_scan_uri_escapes(parser,  | 
 
| 
2626
 | 
 32  | 
 911  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 32  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 943  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 943  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 943  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
2630
 | 
 0  | 
 943  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2635
 | 
 0  | 
 82  | 
     if (!length) {  | 
 
| 
2636
 | 
 0  | 
 0  | 
         if (!STRING_EXTEND(parser, string))  | 
 
| 
 | 
 0  | 
 0  | 
         if (!STRING_EXTEND(parser, string))  | 
 
| 
 | 
 0  | 
 0  | 
         if (!STRING_EXTEND(parser, string))  | 
 
| 
2639
 | 
 0  | 
 0  | 
         yaml_parser_set_scanner_error(parser, directive ?  | 
 
| 
2672
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 3)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 3)) return 0;  | 
 
| 
2674
 | 
 0  | 
 0  | 
         if (!(CHECK(parser->buffer, '%')  | 
 
| 
 | 
 0  | 
 0  | 
         if (!(CHECK(parser->buffer, '%')  | 
 
| 
2675
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 1)  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 1)  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 1)  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 1)  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 1)  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 1)  | 
 
| 
2676
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 2))) {  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 2))) {  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 2))) {  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 2))) {  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_HEX_AT(parser->buffer, 2))) {  | 
 
| 
2677
 | 
 0  | 
 0  | 
             return yaml_parser_set_scanner_error(parser, directive ?  | 
 
| 
2684
 | 
 0  | 
 0  | 
         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);  | 
 
| 
 | 
 0  | 
 0  | 
         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);  | 
 
| 
 | 
 0  | 
 0  | 
         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);  | 
 
| 
 | 
 0  | 
 0  | 
         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);  | 
 
| 
 | 
 0  | 
 0  | 
         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);  | 
 
| 
 | 
 0  | 
 0  | 
         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);  | 
 
| 
 | 
 0  | 
 0  | 
         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);  | 
 
| 
 | 
 0  | 
 0  | 
         octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);  | 
 
| 
2688
 | 
 0  | 
 0  | 
         if (!width)  | 
 
| 
2690
 | 
 0  | 
 0  | 
             width = (octet & 0x80) == 0x00 ? 1 :  | 
 
| 
2691
 | 
 0  | 
 0  | 
                     (octet & 0xE0) == 0xC0 ? 2 :  | 
 
| 
2692
 | 
 0  | 
 0  | 
                     (octet & 0xF0) == 0xE0 ? 3 :  | 
 
| 
2693
 | 
 0  | 
 0  | 
                     (octet & 0xF8) == 0xF0 ? 4 : 0;  | 
 
| 
2694
 | 
 0  | 
 0  | 
             if (!width) {  | 
 
| 
2695
 | 
 0  | 
 0  | 
                 return yaml_parser_set_scanner_error(parser, directive ?  | 
 
| 
2704
 | 
 0  | 
 0  | 
             if ((octet & 0xC0) != 0x80) {  | 
 
| 
2705
 | 
 0  | 
 0  | 
                 return yaml_parser_set_scanner_error(parser, directive ?  | 
 
| 
2714
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2715
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2716
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2718
 | 
 0  | 
 0  | 
     } while (--width);  | 
 
| 
2742
 | 
 7  | 
 0  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 7  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
2743
 | 
 7  | 
 0  | 
     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 7  | 
     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
2744
 | 
 7  | 
 0  | 
     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 7  | 
     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
2750
 | 
 0  | 
 7  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
2754
 | 
 0  | 
 7  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2758
 | 
 7  | 
 0  | 
     if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-'))  | 
 
| 
 | 
 6  | 
 1  | 
     if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-'))  | 
 
| 
2762
 | 
 0  | 
 6  | 
         chomping = CHECK(parser->buffer, '+') ? +1 : -1;  | 
 
| 
2764
 | 
 0  | 
 6  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2768
 | 
 0  | 
 6  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2770
 | 
 0  | 
 6  | 
         if (IS_DIGIT(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         if (IS_DIGIT(parser->buffer))  | 
 
| 
2774
 | 
 0  | 
 0  | 
             if (CHECK(parser->buffer, '0')) {  | 
 
| 
2784
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
2790
 | 
 0  | 
 1  | 
     else if (IS_DIGIT(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
     else if (IS_DIGIT(parser->buffer))  | 
 
| 
2792
 | 
 0  | 
 0  | 
         if (CHECK(parser->buffer, '0')) {  | 
 
| 
2800
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2802
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2804
 | 
 0  | 
 0  | 
         if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) {  | 
 
| 
 | 
 0  | 
 0  | 
         if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) {  | 
 
| 
2805
 | 
 0  | 
 0  | 
             chomping = CHECK(parser->buffer, '+') ? +1 : -1;  | 
 
| 
2807
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
2813
 | 
 0  | 
 7  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2815
 | 
 0  | 
 7  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 7  | 
     while (IS_BLANK(parser->buffer)) {  | 
 
| 
2816
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP(parser);  | 
 
| 
2817
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
2820
 | 
 0  | 
 7  | 
     if (CHECK(parser->buffer, '#')) {  | 
 
| 
2821
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
2822
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
2823
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
2829
 | 
 7  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 7  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
2837
 | 
 7  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 7  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
     if (IS_BREAK(parser->buffer)) {  | 
 
| 
2838
 | 
 0  | 
 7  | 
         if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 2)) goto error;  | 
 
| 
2839
 | 
 0  | 
 7  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 7  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 7  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 7  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
         SKIP_LINE(parser);  | 
 
| 
2846
 | 
 0  | 
 7  | 
     if (increment) {  | 
 
| 
2847
 | 
 0  | 
 0  | 
         indent = parser->indent >= 0 ? parser->indent+increment : increment;  | 
 
| 
2852
 | 
 0  | 
 7  | 
     if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks,  | 
 
| 
2857
 | 
 0  | 
 7  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
     if (!CACHE(parser, 1)) goto error;  | 
 
| 
2859
 | 
 17  | 
 7  | 
     while ((int)parser->mark.column == indent && !(IS_Z(parser->buffer)))  | 
 
| 
 | 
 17  | 
 0  | 
     while ((int)parser->mark.column == indent && !(IS_Z(parser->buffer)))  | 
 
| 
2867
 | 
 10  | 
 7  | 
         trailing_blank = IS_BLANK(parser->buffer);  | 
 
| 
 | 
 0  | 
 10  | 
         trailing_blank = IS_BLANK(parser->buffer);  | 
 
| 
2871
 | 
 0  | 
 17  | 
         if (!literal && (*leading_break.start == '\n')  | 
 
| 
 | 
 0  | 
 0  | 
         if (!literal && (*leading_break.start == '\n')  | 
 
| 
2872
 | 
 0  | 
 0  | 
                 && !leading_blank && !trailing_blank)  | 
 
| 
 | 
 0  | 
 0  | 
                 && !leading_blank && !trailing_blank)  | 
 
| 
2876
 | 
 0  | 
 0  | 
             if (*trailing_breaks.start == '\0') {  | 
 
| 
2877
 | 
 0  | 
 0  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
2884
 | 
 17  | 
 0  | 
             if (!JOIN(parser, string, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 17  | 
             if (!JOIN(parser, string, leading_break)) goto error;  | 
 
| 
2890
 | 
 17  | 
 0  | 
         if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 17  | 
         if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
2895
 | 
 10  | 
 7  | 
         leading_blank = IS_BLANK(parser->buffer);  | 
 
| 
 | 
 0  | 
 10  | 
         leading_blank = IS_BLANK(parser->buffer);  | 
 
| 
2899
 | 
 215  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 198  | 
 17  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 198  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 198  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 198  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
 | 
 198  | 
 0  | 
         while (!IS_BREAKZ(parser->buffer)) {  | 
 
| 
2900
 | 
 10  | 
 188  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 10  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 198  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 198  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 198  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
2901
 | 
 0  | 
 198  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
2906
 | 
 4  | 
 13  | 
         if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 4  | 
         if (!CACHE(parser, 2)) goto error;  | 
 
| 
2908
 | 
 0  | 
 17  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 17  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 17  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 17  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 17  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 17  | 
         if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
2912
 | 
 0  | 
 17  | 
         if (!yaml_parser_scan_block_scalar_breaks(parser,  | 
 
| 
2918
 | 
 1  | 
 6  | 
     if (chomping != -1) {  | 
 
| 
2919
 | 
 1  | 
 0  | 
         if (!JOIN(parser, string, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 1  | 
         if (!JOIN(parser, string, leading_break)) goto error;  | 
 
| 
2921
 | 
 0  | 
 7  | 
     if (chomping == 1) {  | 
 
| 
2922
 | 
 0  | 
 0  | 
         if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
2927
 | 
 7  | 
 0  | 
     SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,  | 
 
| 
2964
 | 
 0  | 
 24  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) return 0;  | 
 
| 
2966
 | 
 37  | 
 21  | 
         while ((!*indent || (int)parser->mark.column < *indent)  | 
 
| 
 | 
 27  | 
 10  | 
         while ((!*indent || (int)parser->mark.column < *indent)  | 
 
| 
2967
 | 
 34  | 
 14  | 
                 && IS_SPACE(parser->buffer)) {  | 
 
| 
2968
 | 
 0  | 
 34  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
             SKIP(parser);  | 
 
| 
2969
 | 
 0  | 
 34  | 
             if (!CACHE(parser, 1)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) return 0;  | 
 
| 
2972
 | 
 17  | 
 7  | 
         if ((int)parser->mark.column > max_indent)  | 
 
| 
2977
 | 
 17  | 
 7  | 
         if ((!*indent || (int)parser->mark.column < *indent)  | 
 
| 
 | 
 7  | 
 10  | 
         if ((!*indent || (int)parser->mark.column < *indent)  | 
 
| 
2978
 | 
 0  | 
 14  | 
                 && IS_TAB(parser->buffer)) {  | 
 
| 
2985
 | 
 24  | 
 0  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 24  | 
 0  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 0  | 
 24  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 0  | 
 24  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 0  | 
 24  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!IS_BREAK(parser->buffer)) break;  | 
 
| 
2989
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 2)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 2)) return 0;  | 
 
| 
2990
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!READ_LINE(parser, *breaks)) return 0;  | 
 
| 
2996
 | 
 7  | 
 17  | 
     if (!*indent) {  | 
 
| 
2998
 | 
 0  | 
 7  | 
         if (*indent < parser->indent + 1)  | 
 
| 
3000
 | 
 0  | 
 7  | 
         if (*indent < 1)  | 
 
| 
3023
 | 
 27  | 
 0  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 27  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
3024
 | 
 27  | 
 0  | 
     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 27  | 
     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
3025
 | 
 27  | 
 0  | 
     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 27  | 
     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
3026
 | 
 27  | 
 0  | 
     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 27  | 
     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
3032
 | 
 0  | 
 27  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
3040
 | 
 2  | 
 32  | 
         if (!CACHE(parser, 4)) goto error;  | 
 
| 
 | 
 0  | 
 2  | 
         if (!CACHE(parser, 4)) goto error;  | 
 
| 
3042
 | 
 1  | 
 33  | 
         if (parser->mark.column == 0 &&  | 
 
| 
 | 
 0  | 
 1  | 
         if (parser->mark.column == 0 &&  | 
 
| 
3043
 | 
 0  | 
 0  | 
             ((CHECK_AT(parser->buffer, '-', 0) &&  | 
 
| 
3044
 | 
 0  | 
 0  | 
               CHECK_AT(parser->buffer, '-', 1) &&  | 
 
| 
3045
 | 
 0  | 
 1  | 
               CHECK_AT(parser->buffer, '-', 2)) ||  | 
 
| 
3046
 | 
 0  | 
 0  | 
              (CHECK_AT(parser->buffer, '.', 0) &&  | 
 
| 
3047
 | 
 0  | 
 0  | 
               CHECK_AT(parser->buffer, '.', 1) &&  | 
 
| 
3048
 | 
 0  | 
 0  | 
               CHECK_AT(parser->buffer, '.', 2))) &&  | 
 
| 
3049
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3))  | 
 
| 
3058
 | 
 0  | 
 34  | 
         if (IS_Z(parser->buffer)) {  | 
 
| 
3066
 | 
 0  | 
 34  | 
         if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 2)) goto error;  | 
 
| 
3070
 | 
 251  | 
 6  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 251  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 251  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 250  | 
 1  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 250  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 250  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 250  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 250  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
3074
 | 
 77  | 
 173  | 
             if (single && CHECK_AT(parser->buffer, '\'', 0)  | 
 
| 
 | 
 16  | 
 61  | 
             if (single && CHECK_AT(parser->buffer, '\'', 0)  | 
 
| 
3075
 | 
 0  | 
 16  | 
                     && CHECK_AT(parser->buffer, '\'', 1))  | 
 
| 
3077
 | 
 0  | 
 0  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
3079
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
3080
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
3085
 | 
 77  | 
 173  | 
             else if (CHECK(parser->buffer, single ? '\'' : '"'))  | 
 
| 
 | 
 27  | 
 223  | 
             else if (CHECK(parser->buffer, single ? '\'' : '"'))  | 
 
| 
3092
 | 
 162  | 
 61  | 
             else if (!single && CHECK(parser->buffer, '\\')  | 
 
| 
 | 
 4  | 
 158  | 
             else if (!single && CHECK(parser->buffer, '\\')  | 
 
| 
3093
 | 
 4  | 
 0  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 4  | 
 0  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 4  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 4  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 4  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
                     && IS_BREAK_AT(parser->buffer, 1))  | 
 
| 
3095
 | 
 0  | 
 0  | 
                 if (!CACHE(parser, 3)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!CACHE(parser, 3)) goto error;  | 
 
| 
3096
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
3097
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP_LINE(parser);  | 
 
| 
3104
 | 
 162  | 
 61  | 
             else if (!single && CHECK(parser->buffer, '\\'))  | 
 
| 
 | 
 4  | 
 158  | 
             else if (!single && CHECK(parser->buffer, '\\'))  | 
 
| 
3108
 | 
 0  | 
 4  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 4  | 
                 if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
3204
 | 
 0  | 
 1  | 
                       if (!parser->problem_nonstrict) {  | 
 
| 
3213
 | 
 0  | 
 4  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
3214
 | 
 0  | 
 4  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                 SKIP(parser);  | 
 
| 
3218
 | 
 0  | 
 4  | 
                 if (code_length)  | 
 
| 
3225
 | 
 0  | 
 0  | 
                     if (!CACHE(parser, code_length)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!CACHE(parser, code_length)) goto error;  | 
 
| 
3227
 | 
 0  | 
 0  | 
                     for (k = 0; k < code_length; k ++) {  | 
 
| 
3228
 | 
 0  | 
 0  | 
                         if (!IS_HEX_AT(parser->buffer, k)) {  | 
 
| 
 | 
 0  | 
 0  | 
                         if (!IS_HEX_AT(parser->buffer, k)) {  | 
 
| 
 | 
 0  | 
 0  | 
                         if (!IS_HEX_AT(parser->buffer, k)) {  | 
 
| 
 | 
 0  | 
 0  | 
                         if (!IS_HEX_AT(parser->buffer, k)) {  | 
 
| 
 | 
 0  | 
 0  | 
                         if (!IS_HEX_AT(parser->buffer, k)) {  | 
 
| 
 | 
 0  | 
 0  | 
                         if (!IS_HEX_AT(parser->buffer, k)) {  | 
 
| 
3233
 | 
 0  | 
 0  | 
                         value = (value << 4) + AS_HEX_AT(parser->buffer, k);  | 
 
| 
 | 
 0  | 
 0  | 
                         value = (value << 4) + AS_HEX_AT(parser->buffer, k);  | 
 
| 
 | 
 0  | 
 0  | 
                         value = (value << 4) + AS_HEX_AT(parser->buffer, k);  | 
 
| 
 | 
 0  | 
 0  | 
                         value = (value << 4) + AS_HEX_AT(parser->buffer, k);  | 
 
| 
3238
 | 
 0  | 
 0  | 
                     if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {  | 
 
| 
 | 
 0  | 
 0  | 
                     if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {  | 
 
| 
 | 
 0  | 
 0  | 
                     if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {  | 
 
| 
3244
 | 
 0  | 
 0  | 
                     if (value <= 0x7F) {  | 
 
| 
3247
 | 
 0  | 
 0  | 
                     else if (value <= 0x7FF) {  | 
 
| 
3251
 | 
 0  | 
 0  | 
                     else if (value <= 0xFFFF) {  | 
 
| 
3265
 | 
 0  | 
 0  | 
                     for (k = 0; k < code_length; k ++) {  | 
 
| 
3266
 | 
 0  | 
 0  | 
                         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                         SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                         SKIP(parser);  | 
 
| 
3275
 | 
 7  | 
 212  | 
                 if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 7  | 
                 if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 219  | 
 0  | 
                 if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 219  | 
 0  | 
                 if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 219  | 
                 if (!READ(parser, string)) goto error;  | 
 
| 
3278
 | 
 0  | 
 223  | 
             if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 2)) goto error;  | 
 
| 
3287
 | 
 0  | 
 34  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
3288
 | 
 16  | 
 18  | 
         if (CHECK(parser->buffer, single ? '\'' : '"'))  | 
 
| 
 | 
 27  | 
 7  | 
         if (CHECK(parser->buffer, single ? '\'' : '"'))  | 
 
| 
3293
 | 
 0  | 
 7  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
3295
 | 
 6  | 
 8  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 8  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 8  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 1  | 
 7  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 7  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 7  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 7  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
3297
 | 
 1  | 
 6  | 
             if (IS_BLANK(parser->buffer))  | 
 
| 
 | 
 0  | 
 1  | 
             if (IS_BLANK(parser->buffer))  | 
 
| 
3301
 | 
 6  | 
 0  | 
                 if (!leading_blanks) {  | 
 
| 
3302
 | 
 0  | 
 6  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 6  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 6  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 6  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
3305
 | 
 0  | 
 0  | 
                     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                     SKIP(parser);  | 
 
| 
3310
 | 
 0  | 
 1  | 
                 if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!CACHE(parser, 2)) goto error;  | 
 
| 
3314
 | 
 1  | 
 0  | 
                 if (!leading_blanks)  | 
 
| 
3317
 | 
 0  | 
 1  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 1  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 1  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 1  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 1  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 1  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
3322
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
3325
 | 
 0  | 
 7  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
3330
 | 
 1  | 
 6  | 
         if (leading_blanks)  | 
 
| 
3334
 | 
 1  | 
 0  | 
             if (leading_break.start[0] == '\n') {  | 
 
| 
3335
 | 
 1  | 
 0  | 
                 if (trailing_breaks.start[0] == '\0') {  | 
 
| 
3336
 | 
 0  | 
 1  | 
                     if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 1  | 
                     if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
3340
 | 
 0  | 
 0  | 
                     if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
3346
 | 
 0  | 
 0  | 
                 if (!JOIN(parser, string, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!JOIN(parser, string, leading_break)) goto error;  | 
 
| 
3347
 | 
 0  | 
 0  | 
                 if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
3354
 | 
 6  | 
 0  | 
             if (!JOIN(parser, string, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 6  | 
             if (!JOIN(parser, string, whitespaces)) goto error;  | 
 
| 
3361
 | 
 0  | 
 27  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
     SKIP(parser);  | 
 
| 
3367
 | 
 16  | 
 11  | 
     SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,  | 
 
| 
3402
 | 
 302  | 
 0  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 302  | 
     if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
3403
 | 
 302  | 
 0  | 
     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 302  | 
     if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
3404
 | 
 302  | 
 0  | 
     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 302  | 
     if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
3405
 | 
 302  | 
 0  | 
     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
 | 
 0  | 
 302  | 
     if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;  | 
 
| 
3415
 | 
 36  | 
 342  | 
         if (!CACHE(parser, 4)) goto error;  | 
 
| 
 | 
 0  | 
 36  | 
         if (!CACHE(parser, 4)) goto error;  | 
 
| 
3417
 | 
 121  | 
 257  | 
         if (parser->mark.column == 0 &&  | 
 
| 
 | 
 7  | 
 114  | 
         if (parser->mark.column == 0 &&  | 
 
| 
3418
 | 
 7  | 
 0  | 
             ((CHECK_AT(parser->buffer, '-', 0) &&  | 
 
| 
3419
 | 
 0  | 
 7  | 
               CHECK_AT(parser->buffer, '-', 1) &&  | 
 
| 
3420
 | 
 0  | 
 114  | 
               CHECK_AT(parser->buffer, '-', 2)) ||  | 
 
| 
3421
 | 
 0  | 
 0  | 
              (CHECK_AT(parser->buffer, '.', 0) &&  | 
 
| 
3422
 | 
 0  | 
 0  | 
               CHECK_AT(parser->buffer, '.', 1) &&  | 
 
| 
3423
 | 
 0  | 
 7  | 
               CHECK_AT(parser->buffer, '.', 2))) &&  | 
 
| 
3424
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
 | 
 0  | 
 0  | 
             IS_BLANKZ_AT(parser->buffer, 3)) break;  | 
 
| 
3428
 | 
 0  | 
 371  | 
         if (CHECK(parser->buffer, '#'))  | 
 
| 
3433
 | 
 1585  | 
 48  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 1585  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 1585  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 1431  | 
 154  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 1431  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 1431  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 1431  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
 | 
 1406  | 
 25  | 
         while (!IS_BLANKZ(parser->buffer))  | 
 
| 
3440
 | 
 72  | 
 1334  | 
             if (parser->flow_level  | 
 
| 
3441
 | 
 7  | 
 65  | 
                     && CHECK(parser->buffer, ':')  | 
 
| 
3442
 | 
 7  | 
 0  | 
                     && (  | 
 
| 
3444
 | 
 7  | 
 0  | 
                         || CHECK_AT(parser->buffer, '?', 1)  | 
 
| 
3445
 | 
 7  | 
 0  | 
                         || CHECK_AT(parser->buffer, '[', 1)  | 
 
| 
3446
 | 
 7  | 
 0  | 
                         || CHECK_AT(parser->buffer, ']', 1)  | 
 
| 
3447
 | 
 7  | 
 0  | 
                         || CHECK_AT(parser->buffer, '{', 1)  | 
 
| 
3448
 | 
 0  | 
 7  | 
                         || CHECK_AT(parser->buffer, '}', 1)  | 
 
| 
3458
 | 
 138  | 
 1268  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 25  | 
 113  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 25  | 
 0  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 25  | 
 0  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 14  | 
 11  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 14  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 14  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 14  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 0  | 
 0  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
 | 
 14  | 
 0  | 
             if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))  | 
 
| 
3459
 | 
 65  | 
 1217  | 
                     || (parser->flow_level &&  | 
 
| 
 | 
 61  | 
 4  | 
                     || (parser->flow_level &&  | 
 
| 
3461
 | 
 61  | 
 0  | 
                          || CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[')  | 
 
| 
 | 
 61  | 
 0  | 
                          || CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[')  | 
 
| 
3462
 | 
 53  | 
 8  | 
                          || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')  | 
 
| 
 | 
 53  | 
 0  | 
                          || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')  | 
 
| 
3463
 | 
 45  | 
 8  | 
                          || CHECK(parser->buffer, '}'))))  | 
 
| 
3468
 | 
 1261  | 
 1  | 
             if (leading_blanks || whitespaces.start != whitespaces.pointer)  | 
 
| 
 | 
 44  | 
 1217  | 
             if (leading_blanks || whitespaces.start != whitespaces.pointer)  | 
 
| 
3470
 | 
 1  | 
 44  | 
                 if (leading_blanks)  | 
 
| 
3474
 | 
 1  | 
 0  | 
                     if (leading_break.start[0] == '\n') {  | 
 
| 
3475
 | 
 1  | 
 0  | 
                         if (trailing_breaks.start[0] == '\0') {  | 
 
| 
3476
 | 
 0  | 
 1  | 
                             if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                             if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 1  | 
                             if (!STRING_EXTEND(parser, string)) goto error;  | 
 
| 
3480
 | 
 0  | 
 0  | 
                             if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                             if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
3486
 | 
 0  | 
 0  | 
                         if (!JOIN(parser, string, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                         if (!JOIN(parser, string, leading_break)) goto error;  | 
 
| 
3487
 | 
 0  | 
 0  | 
                         if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                         if (!JOIN(parser, string, trailing_breaks)) goto error;  | 
 
| 
3496
 | 
 44  | 
 0  | 
                     if (!JOIN(parser, string, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 44  | 
                     if (!JOIN(parser, string, whitespaces)) goto error;  | 
 
| 
3503
 | 
 17  | 
 1245  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 17  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 1262  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 1193  | 
 69  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 12  | 
 57  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 57  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
 | 
 0  | 
 1262  | 
             if (!READ(parser, string)) goto error;  | 
 
| 
3507
 | 
 51  | 
 1211  | 
             if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 51  | 
             if (!CACHE(parser, 2)) goto error;  | 
 
| 
3512
 | 
 323  | 
 48  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 323  | 
 0  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 323  | 
 0  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 169  | 
 154  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 0  | 
 169  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 0  | 
 0  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 0  | 
 169  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 0  | 
 0  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 0  | 
 0  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 0  | 
 169  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 0  | 
 0  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
 | 
 0  | 
 0  | 
         if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))  | 
 
| 
3517
 | 
 0  | 
 202  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
         if (!CACHE(parser, 1)) goto error;  | 
 
| 
3519
 | 
 91  | 
 356  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 356  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 356  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 154  | 
 202  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 202  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 202  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 202  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
 | 
 0  | 
 0  | 
         while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))  | 
 
| 
3521
 | 
 154  | 
 91  | 
             if (IS_BLANK(parser->buffer))  | 
 
| 
 | 
 0  | 
 154  | 
             if (IS_BLANK(parser->buffer))  | 
 
| 
3525
 | 
 43  | 
 48  | 
                 if (leading_blanks && (int)parser->mark.column < indent  | 
 
| 
 | 
 43  | 
 0  | 
                 if (leading_blanks && (int)parser->mark.column < indent  | 
 
| 
3526
 | 
 0  | 
 43  | 
                         && IS_TAB(parser->buffer)) {  | 
 
| 
3534
 | 
 48  | 
 43  | 
                 if (!leading_blanks) {  | 
 
| 
3535
 | 
 0  | 
 48  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 48  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 48  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
 | 
 0  | 
 48  | 
                     if (!READ(parser, whitespaces)) goto error;  | 
 
| 
3538
 | 
 0  | 
 43  | 
                     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                     SKIP(parser);  | 
 
| 
 | 
 0  | 
 0  | 
                     SKIP(parser);  | 
 
| 
3543
 | 
 0  | 
 154  | 
                 if (!CACHE(parser, 2)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                 if (!CACHE(parser, 2)) goto error;  | 
 
| 
3547
 | 
 154  | 
 0  | 
                 if (!leading_blanks)  | 
 
| 
3550
 | 
 0  | 
 154  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 154  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 154  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 154  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 154  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
 | 
 0  | 
 154  | 
                     if (!READ_LINE(parser, leading_break)) goto error;  | 
 
| 
3555
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
                     if (!READ_LINE(parser, trailing_breaks)) goto error;  | 
 
| 
3558
 | 
 0  | 
 245  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
 | 
 0  | 
 0  | 
             if (!CACHE(parser, 1)) goto error;  | 
 
| 
3563
 | 
 198  | 
 4  | 
         if (!parser->flow_level && (int)parser->mark.column < indent)  | 
 
| 
 | 
 126  | 
 72  | 
         if (!parser->flow_level && (int)parser->mark.column < indent)  | 
 
| 
3574
 | 
 153  | 
 149  | 
     if (leading_blanks) {  |