From da6be9fdda23213813883cec6493b93f22b8c6ea Mon Sep 17 00:00:00 2001 From: DJMcNab <36049421+DJMcNab@users.noreply.github.com> Date: Thu, 20 Dec 2018 19:47:29 +0000 Subject: Add weird_exprs test --- .../tests/data/parser/ok/0035_weird_exprs.rs | 149 ++ .../tests/data/parser/ok/0035_weird_exprs.txt | 2236 ++++++++++++++++++++ 2 files changed, 2385 insertions(+) create mode 100644 crates/ra_syntax/tests/data/parser/ok/0035_weird_exprs.rs create mode 100644 crates/ra_syntax/tests/data/parser/ok/0035_weird_exprs.txt (limited to 'crates/ra_syntax/tests/data/parser/ok') diff --git a/crates/ra_syntax/tests/data/parser/ok/0035_weird_exprs.rs b/crates/ra_syntax/tests/data/parser/ok/0035_weird_exprs.rs new file mode 100644 index 000000000..74edc6354 --- /dev/null +++ b/crates/ra_syntax/tests/data/parser/ok/0035_weird_exprs.rs @@ -0,0 +1,149 @@ +#![allow(non_camel_case_types)] +#![allow(dead_code)] +#![allow(unreachable_code)] +#![allow(unused_parens)] + +#![recursion_limit = "128"] + +use std::cell::Cell; +use std::mem::swap; + +// Just a grab bag of stuff that you wouldn't want to actually write. + +fn strange() -> bool { let _x: bool = return true; } + +fn funny() { + fn f(_x: ()) { } + f(return); +} + +fn what() { + fn the(x: &Cell) { + return while !x.get() { x.set(true); }; + } + let i = &Cell::new(false); + let dont = {||the(i)}; + dont(); + assert!((i.get())); +} + +fn zombiejesus() { + loop { + while (return) { + if (return) { + match (return) { + 1 => { + if (return) { + return + } else { + return + } + } + _ => { return } + }; + } else if (return) { + return; + } + } + if (return) { break; } + } +} + +fn notsure() { + let mut _x: isize; + let mut _y = (_x = 0) == (_x = 0); + let mut _z = (_x = 0) < (_x = 0); + let _a = (_x += 0) == (_x = 0); + let _b = swap(&mut _y, &mut _z) == swap(&mut _y, &mut _z); +} + +fn canttouchthis() -> usize { + fn p() -> bool { true } + let _a = (assert!((true)) == (assert!(p()))); + let _c = (assert!((p())) == ()); + let _b: bool = (println!("{}", 0) == (return 0)); +} + +fn angrydome() { + loop { if break { } } + let mut i = 0; + loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => panic!("wat") } } + break; } +} + +fn evil_lincoln() { let _evil = println!("lincoln"); } + +fn dots() { + assert_eq!(String::from(".................................................."), + format!("{:?}", .. .. .. .. .. .. .. .. .. .. .. .. .. + .. .. .. .. .. .. .. .. .. .. .. ..)); +} + +fn u8(u8: u8) { + if u8 != 0u8 { + assert_eq!(8u8, { + macro_rules! u8 { + (u8) => { + mod u8 { + pub fn u8<'u8: 'u8 + 'u8>(u8: &'u8 u8) -> &'u8 u8 { + "u8"; + u8 + } + } + }; + } + + u8!(u8); + let &u8: &u8 = u8::u8(&8u8); + crate::u8(0u8); + u8 + }); + } +} + +fn fishy() { + assert_eq!(String::from("><>"), + String::<>::from::<>("><>").chars::<>().rev::<>().collect::()); +} + +fn union() { + union union<'union> { union: &'union union<'union>, } +} + +fn special_characters() { + let val = !((|(..):(_,_),__@_|__)((&*"\\",'🤔')/**/,{})=={&[..=..][..];})// + ; + assert!(!val); +} + +fn punch_card() -> impl std::fmt::Debug { + ..=..=.. .. .. .. .. .. .. .. .. .. .. ..=.. .. + ..=.. ..=.. .. .. .. .. .. .. .. .. ..=..=..=.. + ..=.. ..=.. ..=.. ..=.. .. ..=..=.. .. ..=.. .. + ..=..=.. .. ..=.. ..=.. ..=.. .. .. .. ..=.. .. + ..=.. ..=.. ..=.. ..=.. .. ..=.. .. .. ..=.. .. + ..=.. ..=.. ..=.. ..=.. .. .. ..=.. .. ..=.. .. + ..=.. ..=.. .. ..=..=.. ..=..=.. .. .. ..=.. .. +} + +fn ktulhu() { + ;;;();;;;;;;;;() +} + +pub fn main() { + strange(); + funny(); + what(); + zombiejesus(); + notsure(); + canttouchthis(); + angrydome(); + evil_lincoln(); + dots(); + u8(8u8); + fishy(); + union(); + special_characters(); + punch_card(); + ktulhu(); +} diff --git a/crates/ra_syntax/tests/data/parser/ok/0035_weird_exprs.txt b/crates/ra_syntax/tests/data/parser/ok/0035_weird_exprs.txt new file mode 100644 index 000000000..e4507c553 --- /dev/null +++ b/crates/ra_syntax/tests/data/parser/ok/0035_weird_exprs.txt @@ -0,0 +1,2236 @@ +SOURCE_FILE@[0; 3542) + ATTR@[0; 31) + POUND@[0; 1) + EXCL@[1; 2) + TOKEN_TREE@[2; 31) + L_BRACK@[2; 3) + IDENT@[3; 8) "allow" + TOKEN_TREE@[8; 30) + L_PAREN@[8; 9) + IDENT@[9; 29) "non_camel_case_types" + R_PAREN@[29; 30) + R_BRACK@[30; 31) + WHITESPACE@[31; 32) + ATTR@[32; 52) + POUND@[32; 33) + EXCL@[33; 34) + TOKEN_TREE@[34; 52) + L_BRACK@[34; 35) + IDENT@[35; 40) "allow" + TOKEN_TREE@[40; 51) + L_PAREN@[40; 41) + IDENT@[41; 50) "dead_code" + R_PAREN@[50; 51) + R_BRACK@[51; 52) + WHITESPACE@[52; 53) + ATTR@[53; 80) + POUND@[53; 54) + EXCL@[54; 55) + TOKEN_TREE@[55; 80) + L_BRACK@[55; 56) + IDENT@[56; 61) "allow" + TOKEN_TREE@[61; 79) + L_PAREN@[61; 62) + IDENT@[62; 78) "unreachable_code" + R_PAREN@[78; 79) + R_BRACK@[79; 80) + WHITESPACE@[80; 81) + ATTR@[81; 105) + POUND@[81; 82) + EXCL@[82; 83) + TOKEN_TREE@[83; 105) + L_BRACK@[83; 84) + IDENT@[84; 89) "allow" + TOKEN_TREE@[89; 104) + L_PAREN@[89; 90) + IDENT@[90; 103) "unused_parens" + R_PAREN@[103; 104) + R_BRACK@[104; 105) + WHITESPACE@[105; 107) + ATTR@[107; 134) + POUND@[107; 108) + EXCL@[108; 109) + TOKEN_TREE@[109; 134) + L_BRACK@[109; 110) + IDENT@[110; 125) "recursion_limit" + WHITESPACE@[125; 126) + EQ@[126; 127) + WHITESPACE@[127; 128) + STRING@[128; 133) + R_BRACK@[133; 134) + WHITESPACE@[134; 136) + USE_ITEM@[136; 156) + USE_KW@[136; 139) + WHITESPACE@[139; 140) + USE_TREE@[140; 155) + PATH@[140; 155) + PATH@[140; 149) + PATH@[140; 143) + PATH_SEGMENT@[140; 143) + NAME_REF@[140; 143) + IDENT@[140; 143) "std" + COLONCOLON@[143; 145) + PATH_SEGMENT@[145; 149) + NAME_REF@[145; 149) + IDENT@[145; 149) "cell" + COLONCOLON@[149; 151) + PATH_SEGMENT@[151; 155) + NAME_REF@[151; 155) + IDENT@[151; 155) "Cell" + SEMI@[155; 156) + WHITESPACE@[156; 157) + USE_ITEM@[157; 176) + USE_KW@[157; 160) + WHITESPACE@[160; 161) + USE_TREE@[161; 175) + PATH@[161; 175) + PATH@[161; 169) + PATH@[161; 164) + PATH_SEGMENT@[161; 164) + NAME_REF@[161; 164) + IDENT@[161; 164) "std" + COLONCOLON@[164; 166) + PATH_SEGMENT@[166; 169) + NAME_REF@[166; 169) + IDENT@[166; 169) "mem" + COLONCOLON@[169; 171) + PATH_SEGMENT@[171; 175) + NAME_REF@[171; 175) + IDENT@[171; 175) "swap" + SEMI@[175; 176) + WHITESPACE@[176; 178) + COMMENT@[178; 247) + WHITESPACE@[247; 249) + FN_DEF@[249; 301) + FN_KW@[249; 251) + WHITESPACE@[251; 252) + NAME@[252; 259) + IDENT@[252; 259) "strange" + PARAM_LIST@[259; 261) + L_PAREN@[259; 260) + R_PAREN@[260; 261) + WHITESPACE@[261; 262) + RET_TYPE@[262; 269) + THIN_ARROW@[262; 264) + WHITESPACE@[264; 265) + PATH_TYPE@[265; 269) + PATH@[265; 269) + PATH_SEGMENT@[265; 269) + NAME_REF@[265; 269) + IDENT@[265; 269) "bool" + WHITESPACE@[269; 270) + BLOCK@[270; 301) + L_CURLY@[270; 271) + WHITESPACE@[271; 272) + LET_STMT@[272; 299) + LET_KW@[272; 275) + WHITESPACE@[275; 276) + BIND_PAT@[276; 278) + NAME@[276; 278) + IDENT@[276; 278) "_x" + COLON@[278; 279) + WHITESPACE@[279; 280) + PATH_TYPE@[280; 284) + PATH@[280; 284) + PATH_SEGMENT@[280; 284) + NAME_REF@[280; 284) + IDENT@[280; 284) "bool" + WHITESPACE@[284; 285) + EQ@[285; 286) + WHITESPACE@[286; 287) + RETURN_EXPR@[287; 298) + RETURN_KW@[287; 293) + WHITESPACE@[293; 294) + LITERAL@[294; 298) + TRUE_KW@[294; 298) + SEMI@[298; 299) + WHITESPACE@[299; 300) + R_CURLY@[300; 301) + WHITESPACE@[301; 303) + FN_DEF@[303; 353) + FN_KW@[303; 305) + WHITESPACE@[305; 306) + NAME@[306; 311) + IDENT@[306; 311) "funny" + PARAM_LIST@[311; 313) + L_PAREN@[311; 312) + R_PAREN@[312; 313) + WHITESPACE@[313; 314) + BLOCK@[314; 353) + L_CURLY@[314; 315) + WHITESPACE@[315; 320) + FN_DEF@[320; 336) + FN_KW@[320; 322) + WHITESPACE@[322; 323) + NAME@[323; 324) + IDENT@[323; 324) "f" + PARAM_LIST@[324; 332) + L_PAREN@[324; 325) + PARAM@[325; 331) + BIND_PAT@[325; 327) + NAME@[325; 327) + IDENT@[325; 327) "_x" + COLON@[327; 328) + WHITESPACE@[328; 329) + TUPLE_TYPE@[329; 331) + L_PAREN@[329; 330) + R_PAREN@[330; 331) + R_PAREN@[331; 332) + WHITESPACE@[332; 333) + BLOCK@[333; 336) + L_CURLY@[333; 334) + WHITESPACE@[334; 335) + R_CURLY@[335; 336) + WHITESPACE@[336; 341) + EXPR_STMT@[341; 351) + CALL_EXPR@[341; 350) + PATH_EXPR@[341; 342) + PATH@[341; 342) + PATH_SEGMENT@[341; 342) + NAME_REF@[341; 342) + IDENT@[341; 342) "f" + ARG_LIST@[342; 350) + L_PAREN@[342; 343) + RETURN_EXPR@[343; 349) + RETURN_KW@[343; 349) + R_PAREN@[349; 350) + SEMI@[350; 351) + WHITESPACE@[351; 352) + R_CURLY@[352; 353) + WHITESPACE@[353; 355) + FN_DEF@[355; 545) + FN_KW@[355; 357) + WHITESPACE@[357; 358) + NAME@[358; 362) + IDENT@[358; 362) "what" + PARAM_LIST@[362; 364) + L_PAREN@[362; 363) + R_PAREN@[363; 364) + WHITESPACE@[364; 365) + BLOCK@[365; 545) + L_CURLY@[365; 366) + WHITESPACE@[366; 371) + FN_DEF@[371; 449) + FN_KW@[371; 373) + WHITESPACE@[373; 374) + NAME@[374; 377) + IDENT@[374; 377) "the" + PARAM_LIST@[377; 393) + L_PAREN@[377; 378) + PARAM@[378; 392) + BIND_PAT@[378; 379) + NAME@[378; 379) + IDENT@[378; 379) "x" + COLON@[379; 380) + WHITESPACE@[380; 381) + REFERENCE_TYPE@[381; 392) + AMP@[381; 382) + PATH_TYPE@[382; 392) + PATH@[382; 392) + PATH_SEGMENT@[382; 392) + NAME_REF@[382; 386) + IDENT@[382; 386) "Cell" + TYPE_ARG_LIST@[386; 392) + L_ANGLE@[386; 387) + TYPE_ARG@[387; 391) + PATH_TYPE@[387; 391) + PATH@[387; 391) + PATH_SEGMENT@[387; 391) + NAME_REF@[387; 391) + IDENT@[387; 391) "bool" + R_ANGLE@[391; 392) + R_PAREN@[392; 393) + WHITESPACE@[393; 394) + BLOCK@[394; 449) + L_CURLY@[394; 395) + WHITESPACE@[395; 404) + EXPR_STMT@[404; 443) + RETURN_EXPR@[404; 442) + RETURN_KW@[404; 410) + WHITESPACE@[410; 411) + WHILE_EXPR@[411; 442) + WHILE_KW@[411; 416) + WHITESPACE@[416; 417) + CONDITION@[417; 425) + PREFIX_EXPR@[417; 425) + EXCL@[417; 418) + METHOD_CALL_EXPR@[418; 425) + PATH_EXPR@[418; 419) + PATH@[418; 419) + PATH_SEGMENT@[418; 419) + NAME_REF@[418; 419) + IDENT@[418; 419) "x" + DOT@[419; 420) + NAME_REF@[420; 423) + IDENT@[420; 423) "get" + ARG_LIST@[423; 425) + L_PAREN@[423; 424) + R_PAREN@[424; 425) + WHITESPACE@[425; 426) + BLOCK@[426; 442) + L_CURLY@[426; 427) + WHITESPACE@[427; 428) + EXPR_STMT@[428; 440) + METHOD_CALL_EXPR@[428; 439) + PATH_EXPR@[428; 429) + PATH@[428; 429) + PATH_SEGMENT@[428; 429) + NAME_REF@[428; 429) + IDENT@[428; 429) "x" + DOT@[429; 430) + NAME_REF@[430; 433) + IDENT@[430; 433) "set" + ARG_LIST@[433; 439) + L_PAREN@[433; 434) + LITERAL@[434; 438) + TRUE_KW@[434; 438) + R_PAREN@[438; 439) + SEMI@[439; 440) + WHITESPACE@[440; 441) + R_CURLY@[441; 442) + SEMI@[442; 443) + WHITESPACE@[443; 448) + R_CURLY@[448; 449) + WHITESPACE@[449; 454) + LET_STMT@[454; 480) + LET_KW@[454; 457) + WHITESPACE@[457; 458) + BIND_PAT@[458; 459) + NAME@[458; 459) + IDENT@[458; 459) "i" + WHITESPACE@[459; 460) + EQ@[460; 461) + WHITESPACE@[461; 462) + REF_EXPR@[462; 479) + AMP@[462; 463) + CALL_EXPR@[463; 479) + PATH_EXPR@[463; 472) + PATH@[463; 472) + PATH@[463; 467) + PATH_SEGMENT@[463; 467) + NAME_REF@[463; 467) + IDENT@[463; 467) "Cell" + COLONCOLON@[467; 469) + PATH_SEGMENT@[469; 472) + NAME_REF@[469; 472) + IDENT@[469; 472) "new" + ARG_LIST@[472; 479) + L_PAREN@[472; 473) + LITERAL@[473; 478) + FALSE_KW@[473; 478) + R_PAREN@[478; 479) + SEMI@[479; 480) + WHITESPACE@[480; 485) + LET_STMT@[485; 507) + LET_KW@[485; 488) + WHITESPACE@[488; 489) + BIND_PAT@[489; 493) + NAME@[489; 493) + IDENT@[489; 493) "dont" + WHITESPACE@[493; 494) + EQ@[494; 495) + WHITESPACE@[495; 496) + BLOCK_EXPR@[496; 506) + BLOCK@[496; 506) + L_CURLY@[496; 497) + LAMBDA_EXPR@[497; 505) + PARAM_LIST@[497; 499) + PIPE@[497; 498) + PIPE@[498; 499) + CALL_EXPR@[499; 505) + PATH_EXPR@[499; 502) + PATH@[499; 502) + PATH_SEGMENT@[499; 502) + NAME_REF@[499; 502) + IDENT@[499; 502) "the" + ARG_LIST@[502; 505) + L_PAREN@[502; 503) + PATH_EXPR@[503; 504) + PATH@[503; 504) + PATH_SEGMENT@[503; 504) + NAME_REF@[503; 504) + IDENT@[503; 504) "i" + R_PAREN@[504; 505) + R_CURLY@[505; 506) + SEMI@[506; 507) + WHITESPACE@[507; 512) + EXPR_STMT@[512; 519) + CALL_EXPR@[512; 518) + PATH_EXPR@[512; 516) + PATH@[512; 516) + PATH_SEGMENT@[512; 516) + NAME_REF@[512; 516) + IDENT@[512; 516) "dont" + ARG_LIST@[516; 518) + L_PAREN@[516; 517) + R_PAREN@[517; 518) + SEMI@[518; 519) + WHITESPACE@[519; 524) + EXPR_STMT@[524; 543) + MACRO_CALL@[524; 542) + PATH@[524; 530) + PATH_SEGMENT@[524; 530) + NAME_REF@[524; 530) + IDENT@[524; 530) "assert" + EXCL@[530; 531) + TOKEN_TREE@[531; 542) + L_PAREN@[531; 532) + TOKEN_TREE@[532; 541) + L_PAREN@[532; 533) + IDENT@[533; 534) "i" + DOT@[534; 535) + IDENT@[535; 538) "get" + TOKEN_TREE@[538; 540) + L_PAREN@[538; 539) + R_PAREN@[539; 540) + R_PAREN@[540; 541) + R_PAREN@[541; 542) + SEMI@[542; 543) + WHITESPACE@[543; 544) + R_CURLY@[544; 545) + WHITESPACE@[545; 547) + FN_DEF@[547; 1051) + FN_KW@[547; 549) + WHITESPACE@[549; 550) + NAME@[550; 561) + IDENT@[550; 561) "zombiejesus" + PARAM_LIST@[561; 563) + L_PAREN@[561; 562) + R_PAREN@[562; 563) + WHITESPACE@[563; 564) + BLOCK@[564; 1051) + L_CURLY@[564; 565) + WHITESPACE@[565; 570) + LOOP_EXPR@[570; 1049) + LOOP_KW@[570; 574) + WHITESPACE@[574; 575) + BLOCK@[575; 1049) + L_CURLY@[575; 576) + WHITESPACE@[576; 585) + EXPR_STMT@[585; 1012) + WHILE_EXPR@[585; 1012) + WHILE_KW@[585; 590) + WHITESPACE@[590; 591) + CONDITION@[591; 599) + PAREN_EXPR@[591; 599) + L_PAREN@[591; 592) + RETURN_EXPR@[592; 598) + RETURN_KW@[592; 598) + R_PAREN@[598; 599) + WHITESPACE@[599; 600) + BLOCK@[600; 1012) + L_CURLY@[600; 601) + WHITESPACE@[601; 614) + IF_EXPR@[614; 1002) + IF_KW@[614; 616) + WHITESPACE@[616; 617) + CONDITION@[617; 625) + PAREN_EXPR@[617; 625) + L_PAREN@[617; 618) + RETURN_EXPR@[618; 624) + RETURN_KW@[618; 624) + R_PAREN@[624; 625) + WHITESPACE@[625; 626) + BLOCK@[626; 945) + L_CURLY@[626; 627) + WHITESPACE@[627; 644) + EXPR_STMT@[644; 931) + MATCH_EXPR@[644; 930) + MATCH_KW@[644; 649) + WHITESPACE@[649; 650) + PAREN_EXPR@[650; 658) + L_PAREN@[650; 651) + RETURN_EXPR@[651; 657) + RETURN_KW@[651; 657) + R_PAREN@[657; 658) + WHITESPACE@[658; 659) + MATCH_ARM_LIST@[659; 930) + L_CURLY@[659; 660) + WHITESPACE@[660; 681) + MATCH_ARM@[681; 876) + LITERAL@[681; 682) + INT_NUMBER@[681; 682) "1" + WHITESPACE@[682; 683) + FAT_ARROW@[683; 685) + WHITESPACE@[685; 686) + BLOCK_EXPR@[686; 876) + BLOCK@[686; 876) + L_CURLY@[686; 687) + WHITESPACE@[687; 712) + IF_EXPR@[712; 854) + IF_KW@[712; 714) + WHITESPACE@[714; 715) + CONDITION@[715; 723) + PAREN_EXPR@[715; 723) + L_PAREN@[715; 716) + RETURN_EXPR@[716; 722) + RETURN_KW@[716; 722) + R_PAREN@[722; 723) + WHITESPACE@[723; 724) + BLOCK@[724; 786) + L_CURLY@[724; 725) + WHITESPACE@[725; 754) + RETURN_EXPR@[754; 760) + RETURN_KW@[754; 760) + WHITESPACE@[760; 785) + R_CURLY@[785; 786) + WHITESPACE@[786; 787) + ELSE_KW@[787; 791) + WHITESPACE@[791; 792) + BLOCK@[792; 854) + L_CURLY@[792; 793) + WHITESPACE@[793; 822) + RETURN_EXPR@[822; 828) + RETURN_KW@[822; 828) + WHITESPACE@[828; 853) + R_CURLY@[853; 854) + WHITESPACE@[854; 875) + R_CURLY@[875; 876) + WHITESPACE@[876; 897) + MATCH_ARM@[897; 912) + PLACEHOLDER_PAT@[897; 898) + UNDERSCORE@[897; 898) + WHITESPACE@[898; 899) + FAT_ARROW@[899; 901) + WHITESPACE@[901; 902) + BLOCK_EXPR@[902; 912) + BLOCK@[902; 912) + L_CURLY@[902; 903) + WHITESPACE@[903; 904) + RETURN_EXPR@[904; 910) + RETURN_KW@[904; 910) + WHITESPACE@[910; 911) + R_CURLY@[911; 912) + WHITESPACE@[912; 929) + R_CURLY@[929; 930) + SEMI@[930; 931) + WHITESPACE@[931; 944) + R_CURLY@[944; 945) + WHITESPACE@[945; 946) + ELSE_KW@[946; 950) + WHITESPACE@[950; 951) + IF_EXPR@[951; 1002) + IF_KW@[951; 953) + WHITESPACE@[953; 954) + CONDITION@[954; 962) + PAREN_EXPR@[954; 962) + L_PAREN@[954; 955) + RETURN_EXPR@[955; 961) + RETURN_KW@[955; 961) + R_PAREN@[961; 962) + WHITESPACE@[962; 963) + BLOCK@[963; 1002) + L_CURLY@[963; 964) + WHITESPACE@[964; 981) + EXPR_STMT@[981; 988) + RETURN_EXPR@[981; 987) + RETURN_KW@[981; 987) + SEMI@[987; 988) + WHITESPACE@[988; 1001) + R_CURLY@[1001; 1002) + WHITESPACE@[1002; 1011) + R_CURLY@[1011; 1012) + WHITESPACE@[1012; 1021) + IF_EXPR@[1021; 1043) + IF_KW@[1021; 1023) + WHITESPACE@[1023; 1024) + CONDITION@[1024; 1032) + PAREN_EXPR@[1024; 1032) + L_PAREN@[1024; 1025) + RETURN_EXPR@[1025; 1031) + RETURN_KW@[1025; 1031) + R_PAREN@[1031; 1032) + WHITESPACE@[1032; 1033) + BLOCK@[1033; 1043) + L_CURLY@[1033; 1034) + WHITESPACE@[1034; 1035) + EXPR_STMT@[1035; 1041) + BREAK_EXPR@[1035; 1040) + BREAK_KW@[1035; 1040) + SEMI@[1040; 1041) + WHITESPACE@[1041; 1042) + R_CURLY@[1042; 1043) + WHITESPACE@[1043; 1048) + R_CURLY@[1048; 1049) + WHITESPACE@[1049; 1050) + R_CURLY@[1050; 1051) + WHITESPACE@[1051; 1053) + FN_DEF@[1053; 1268) + FN_KW@[1053; 1055) + WHITESPACE@[1055; 1056) + NAME@[1056; 1063) + IDENT@[1056; 1063) "notsure" + PARAM_LIST@[1063; 1065) + L_PAREN@[1063; 1064) + R_PAREN@[1064; 1065) + WHITESPACE@[1065; 1066) + BLOCK@[1066; 1268) + L_CURLY@[1066; 1067) + WHITESPACE@[1067; 1072) + LET_STMT@[1072; 1090) + LET_KW@[1072; 1075) + WHITESPACE@[1075; 1076) + BIND_PAT@[1076; 1082) + MUT_KW@[1076; 1079) + WHITESPACE@[1079; 1080) + NAME@[1080; 1082) + IDENT@[1080; 1082) "_x" + COLON@[1082; 1083) + WHITESPACE@[1083; 1084) + PATH_TYPE@[1084; 1089) + PATH@[1084; 1089) + PATH_SEGMENT@[1084; 1089) + NAME_REF@[1084; 1089) + IDENT@[1084; 1089) "isize" + SEMI@[1089; 1090) + WHITESPACE@[1090; 1095) + LET_STMT@[1095; 1129) + LET_KW@[1095; 1098) + WHITESPACE@[1098; 1099) + BIND_PAT@[1099; 1105) + MUT_KW@[1099; 1102) + WHITESPACE@[1102; 1103) + NAME@[1103; 1105) + IDENT@[1103; 1105) "_y" + WHITESPACE@[1105; 1106) + EQ@[1106; 1107) + WHITESPACE@[1107; 1108) + BIN_EXPR@[1108; 1128) + PAREN_EXPR@[1108; 1116) + L_PAREN@[1108; 1109) + BIN_EXPR@[1109; 1115) + PATH_EXPR@[1109; 1111) + PATH@[1109; 1111) + PATH_SEGMENT@[1109; 1111) + NAME_REF@[1109; 1111) + IDENT@[1109; 1111) "_x" + WHITESPACE@[1111; 1112) + EQ@[1112; 1113) + WHITESPACE@[1113; 1114) + LITERAL@[1114; 1115) + INT_NUMBER@[1114; 1115) "0" + R_PAREN@[1115; 1116) + WHITESPACE@[1116; 1117) + EQEQ@[1117; 1119) + WHITESPACE@[1119; 1120) + PAREN_EXPR@[1120; 1128) + L_PAREN@[1120; 1121) + BIN_EXPR@[1121; 1127) + PATH_EXPR@[1121; 1123) + PATH@[1121; 1123) + PATH_SEGMENT@[1121; 1123) + NAME_REF@[1121; 1123) + IDENT@[1121; 1123) "_x" + WHITESPACE@[1123; 1124) + EQ@[1124; 1125) + WHITESPACE@[1125; 1126) + LITERAL@[1126; 1127) + INT_NUMBER@[1126; 1127) "0" + R_PAREN@[1127; 1128) + SEMI@[1128; 1129) + WHITESPACE@[1129; 1134) + LET_STMT@[1134; 1167) + LET_KW@[1134; 1137) + WHITESPACE@[1137; 1138) + BIND_PAT@[1138; 1144) + MUT_KW@[1138; 1141) + WHITESPACE@[1141; 1142) + NAME@[1142; 1144) + IDENT@[1142; 1144) "_z" + WHITESPACE@[1144; 1145) + EQ@[1145; 1146) + WHITESPACE@[1146; 1147) + BIN_EXPR@[1147; 1166) + PAREN_EXPR@[1147; 1155) + L_PAREN@[1147; 1148) + BIN_EXPR@[1148; 1154) + PATH_EXPR@[1148; 1150) + PATH@[1148; 1150) + PATH_SEGMENT@[1148; 1150) + NAME_REF@[1148; 1150) + IDENT@[1148; 1150) "_x" + WHITESPACE@[1150; 1151) + EQ@[1151; 1152) + WHITESPACE@[1152; 1153) + LITERAL@[1153; 1154) + INT_NUMBER@[1153; 1154) "0" + R_PAREN@[1154; 1155) + WHITESPACE@[1155; 1156) + L_ANGLE@[1156; 1157) + WHITESPACE@[1157; 1158) + PAREN_EXPR@[1158; 1166) + L_PAREN@[1158; 1159) + BIN_EXPR@[1159; 1165) + PATH_EXPR@[1159; 1161) + PATH@[1159; 1161) + PATH_SEGMENT@[1159; 1161) + NAME_REF@[1159; 1161) + IDENT@[1159; 1161) "_x" + WHITESPACE@[1161; 1162) + EQ@[1162; 1163) + WHITESPACE@[1163; 1164) + LITERAL@[1164; 1165) + INT_NUMBER@[1164; 1165) "0" + R_PAREN@[1165; 1166) + SEMI@[1166; 1167) + WHITESPACE@[1167; 1172) + LET_STMT@[1172; 1203) + LET_KW@[1172; 1175) + WHITESPACE@[1175; 1176) + BIND_PAT@[1176; 1178) + NAME@[1176; 1178) + IDENT@[1176; 1178) "_a" + WHITESPACE@[1178; 1179) + EQ@[1179; 1180) + WHITESPACE@[1180; 1181) + BIN_EXPR@[1181; 1202) + PAREN_EXPR@[1181; 1190) + L_PAREN@[1181; 1182) + BIN_EXPR@[1182; 1189) + PATH_EXPR@[1182; 1184) + PATH@[1182; 1184) + PATH_SEGMENT@[1182; 1184) + NAME_REF@[1182; 1184) + IDENT@[1182; 1184) "_x" + WHITESPACE@[1184; 1185) + PLUSEQ@[1185; 1187) + WHITESPACE@[1187; 1188) + LITERAL@[1188; 1189) + INT_NUMBER@[1188; 1189) "0" + R_PAREN@[1189; 1190) + WHITESPACE@[1190; 1191) + EQEQ@[1191; 1193) + WHITESPACE@[1193; 1194) + PAREN_EXPR@[1194; 1202) + L_PAREN@[1194; 1195) + BIN_EXPR@[1195; 1201) + PATH_EXPR@[1195; 1197) + PATH@[1195; 1197) + PATH_SEGMENT@[1195; 1197) + NAME_REF@[1195; 1197) + IDENT@[1195; 1197) "_x" + WHITESPACE@[1197; 1198) + EQ@[1198; 1199) + WHITESPACE@[1199; 1200) + LITERAL@[1200; 1201) + INT_NUMBER@[1200; 1201) "0" + R_PAREN@[1201; 1202) + SEMI@[1202; 1203) + WHITESPACE@[1203; 1208) + LET_STMT@[1208; 1266) + LET_KW@[1208; 1211) + WHITESPACE@[1211; 1212) + BIND_PAT@[1212; 1214) + NAME@[1212; 1214) + IDENT@[1212; 1214) "_b" + WHITESPACE@[1214; 1215) + EQ@[1215; 1216) + WHITESPACE@[1216; 1217) + BIN_EXPR@[1217; 1265) + CALL_EXPR@[1217; 1239) + PATH_EXPR@[1217; 1221) + PATH@[1217; 1221) + PATH_SEGMENT@[1217; 1221) + NAME_REF@[1217; 1221) + IDENT@[1217; 1221) "swap" + ARG_LIST@[1221; 1239) + L_PAREN@[1221; 1222) + REF_EXPR@[1222; 1229) + AMP@[1222; 1223) + MUT_KW@[1223; 1226) + WHITESPACE@[1226; 1227) + PATH_EXPR@[1227; 1229) + PATH@[1227; 1229) + PATH_SEGMENT@[1227; 1229) + NAME_REF@[1227; 1229) + IDENT@[1227; 1229) "_y" + COMMA@[1229; 1230) + WHITESPACE@[1230; 1231) + REF_EXPR@[1231; 1238) + AMP@[1231; 1232) + MUT_KW@[1232; 1235) + WHITESPACE@[1235; 1236) + PATH_EXPR@[1236; 1238) + PATH@[1236; 1238) + PATH_SEGMENT@[1236; 1238) + NAME_REF@[1236; 1238) + IDENT@[1236; 1238) "_z" + R_PAREN@[1238; 1239) + WHITESPACE@[1239; 1240) + EQEQ@[1240; 1242) + WHITESPACE@[1242; 1243) + CALL_EXPR@[1243; 1265) + PATH_EXPR@[1243; 1247) + PATH@[1243; 1247) + PATH_SEGMENT@[1243; 1247) + NAME_REF@[1243; 1247) + IDENT@[1243; 1247) "swap" + ARG_LIST@[1247; 1265) + L_PAREN@[1247; 1248) + REF_EXPR@[1248; 1255) + AMP@[1248; 1249) + MUT_KW@[1249; 1252) + WHITESPACE@[1252; 1253) + PATH_EXPR@[1253; 1255) + PATH@[1253; 1255) + PATH_SEGMENT@[1253; 1255) + NAME_REF@[1253; 1255) + IDENT@[1253; 1255) "_y" + COMMA@[1255; 1256) + WHITESPACE@[1256; 1257) + REF_EXPR@[1257; 1264) + AMP@[1257; 1258) + MUT_KW@[1258; 1261) + WHITESPACE@[1261; 1262) + PATH_EXPR@[1262; 1264) + PATH@[1262; 1264) + PATH_SEGMENT@[1262; 1264) + NAME_REF@[1262; 1264) + IDENT@[1262; 1264) "_z" + R_PAREN@[1264; 1265) + SEMI@[1265; 1266) + WHITESPACE@[1266; 1267) + R_CURLY@[1267; 1268) + WHITESPACE@[1268; 1270) + FN_DEF@[1270; 1470) + FN_KW@[1270; 1272) + WHITESPACE@[1272; 1273) + NAME@[1273; 1286) + IDENT@[1273; 1286) "canttouchthis" + PARAM_LIST@[1286; 1288) + L_PAREN@[1286; 1287) + R_PAREN@[1287; 1288) + WHITESPACE@[1288; 1289) + RET_TYPE@[1289; 1297) + THIN_ARROW@[1289; 1291) + WHITESPACE@[1291; 1292) + PATH_TYPE@[1292; 1297) + PATH@[1292; 1297) + PATH_SEGMENT@[1292; 1297) + NAME_REF@[1292; 1297) + IDENT@[1292; 1297) "usize" + WHITESPACE@[1297; 1298) + BLOCK@[1298; 1470) + L_CURLY@[1298; 1299) + WHITESPACE@[1299; 1304) + FN_DEF@[1304; 1327) + FN_KW@[1304; 1306) + WHITESPACE@[1306; 1307) + NAME@[1307; 1308) + IDENT@[1307; 1308) "p" + PARAM_LIST@[1308; 1310) + L_PAREN@[1308; 1309) + R_PAREN@[1309; 1310) + WHITESPACE@[1310; 1311) + RET_TYPE@[1311; 1318) + THIN_ARROW@[1311; 1313) + WHITESPACE@[1313; 1314) + PATH_TYPE@[1314; 1318) + PATH@[1314; 1318) + PATH_SEGMENT@[1314; 1318) + NAME_REF@[1314; 1318) + IDENT@[1314; 1318) "bool" + WHITESPACE@[1318; 1319) + BLOCK@[1319; 1327) + L_CURLY@[1319; 1320) + WHITESPACE@[1320; 1321) + LITERAL@[1321; 1325) + TRUE_KW@[1321; 1325) + WHITESPACE@[1325; 1326) + R_CURLY@[1326; 1327) + WHITESPACE@[1327; 1332) + LET_STMT@[1332; 1377) + LET_KW@[1332; 1335) + WHITESPACE@[1335; 1336) + BIND_PAT@[1336; 1338) + NAME@[1336; 1338) + IDENT@[1336; 1338) "_a" + WHITESPACE@[1338; 1339) + EQ@[1339; 1340) + WHITESPACE@[1340; 1341) + PAREN_EXPR@[1341; 1376) + L_PAREN@[1341; 1342) + BIN_EXPR@[1342; 1375) + MACRO_CALL@[1342; 1357) + PATH@[1342; 1348) + PATH_SEGMENT@[1342; 1348) + NAME_REF@[1342; 1348) + IDENT@[1342; 1348) "assert" + EXCL@[1348; 1349) + TOKEN_TREE@[1349; 1357) + L_PAREN@[1349; 1350) + TOKEN_TREE@[1350; 1356) + L_PAREN@[1350; 1351) + TRUE_KW@[1351; 1355) + R_PAREN@[1355; 1356) + R_PAREN@[1356; 1357) + WHITESPACE@[1357; 1358) + EQEQ@[1358; 1360) + WHITESPACE@[1360; 1361) + PAREN_EXPR@[1361; 1375) + L_PAREN@[1361; 1362) + MACRO_CALL@[1362; 1374) + PATH@[1362; 1368) + PATH_SEGMENT@[1362; 1368) + NAME_REF@[1362; 1368) + IDENT@[1362; 1368) "assert" + EXCL@[1368; 1369) + TOKEN_TREE@[1369; 1374) + L_PAREN@[1369; 1370) + IDENT@[1370; 1371) "p" + TOKEN_TREE@[1371; 1373) + L_PAREN@[1371; 1372) + R_PAREN@[1372; 1373) + R_PAREN@[1373; 1374) + R_PAREN@[1374; 1375) + R_PAREN@[1375; 1376) + SEMI@[1376; 1377) + WHITESPACE@[1377; 1382) + LET_STMT@[1382; 1414) + LET_KW@[1382; 1385) + WHITESPACE@[1385; 1386) + BIND_PAT@[1386; 1388) + NAME@[1386; 1388) + IDENT@[1386; 1388) "_c" + WHITESPACE@[1388; 1389) + EQ@[1389; 1390) + WHITESPACE@[1390; 1391) + PAREN_EXPR@[1391; 1413) + L_PAREN@[1391; 1392) + BIN_EXPR@[1392; 1412) + MACRO_CALL@[1392; 1406) + PATH@[1392; 1398) + PATH_SEGMENT@[1392; 1398) + NAME_REF@[1392; 1398) + IDENT@[1392; 1398) "assert" + EXCL@[1398; 1399) + TOKEN_TREE@[1399; 1406) + L_PAREN@[1399; 1400) + TOKEN_TREE@[1400; 1405) + L_PAREN@[1400; 1401) + IDENT@[1401; 1402) "p" + TOKEN_TREE@[1402; 1404) + L_PAREN@[1402; 1403) + R_PAREN@[1403; 1404) + R_PAREN@[1404; 1405) + R_PAREN@[1405; 1406) + WHITESPACE@[1406; 1407) + EQEQ@[1407; 1409) + WHITESPACE@[1409; 1410) + TUPLE_EXPR@[1410; 1412) + L_PAREN@[1410; 1411) + R_PAREN@[1411; 1412) + R_PAREN@[1412; 1413) + SEMI@[1413; 1414) + WHITESPACE@[1414; 1419) + LET_STMT@[1419; 1468) + LET_KW@[1419; 1422) + WHITESPACE@[1422; 1423) + BIND_PAT@[1423; 1425) + NAME@[1423; 1425) + IDENT@[1423; 1425) "_b" + COLON@[1425; 1426) + WHITESPACE@[1426; 1427) + PATH_TYPE@[1427; 1431) + PATH@[1427; 1431) + PATH_SEGMENT@[1427; 1431) + NAME_REF@[1427; 1431) + IDENT@[1427; 1431) "bool" + WHITESPACE@[1431; 1432) + EQ@[1432; 1433) + WHITESPACE@[1433; 1434) + PAREN_EXPR@[1434; 1467) + L_PAREN@[1434; 1435) + BIN_EXPR@[1435; 1466) + MACRO_CALL@[1435; 1452) + PATH@[1435; 1442) + PATH_SEGMENT@[1435; 1442) + NAME_REF@[1435; 1442) + IDENT@[1435; 1442) "println" + EXCL@[1442; 1443) + TOKEN_TREE@[1443; 1452) + L_PAREN@[1443; 1444) + STRING@[1444; 1448) + COMMA@[1448; 1449) + WHITESPACE@[1449; 1450) + INT_NUMBER@[1450; 1451) "0" + R_PAREN@[1451; 1452) + WHITESPACE@[1452; 1453) + EQEQ@[1453; 1455) + WHITESPACE@[1455; 1456) + PAREN_EXPR@[1456; 1466) + L_PAREN@[1456; 1457) + RETURN_EXPR@[1457; 1465) + RETURN_KW@[1457; 1463) + WHITESPACE@[1463; 1464) + LITERAL@[1464; 1465) + INT_NUMBER@[1464; 1465) "0" + R_PAREN@[1465; 1466) + R_PAREN@[1466; 1467) + SEMI@[1467; 1468) + WHITESPACE@[1468; 1469) + R_CURLY@[1469; 1470) + WHITESPACE@[1470; 1472) + FN_DEF@[1472; 1633) + FN_KW@[1472; 1474) + WHITESPACE@[1474; 1475) + NAME@[1475; 1484) + IDENT@[1475; 1484) "angrydome" + PARAM_LIST@[1484; 1486) + L_PAREN@[1484; 1485) + R_PAREN@[1485; 1486) + WHITESPACE@[1486; 1487) + BLOCK@[1487; 1633) + L_CURLY@[1487; 1488) + WHITESPACE@[1488; 1493) + EXPR_STMT@[1493; 1514) + LOOP_EXPR@[1493; 1514) + LOOP_KW@[1493; 1497) + WHITESPACE@[1497; 1498) + BLOCK@[1498; 1514) + L_CURLY@[1498; 1499) + WHITESPACE@[1499; 1500) + IF_EXPR@[1500; 1512) + IF_KW@[1500; 1502) + WHITESPACE@[1502; 1503) + CONDITION@[1503; 1508) + BREAK_EXPR@[1503; 1508) + BREAK_KW@[1503; 1508) + WHITESPACE@[1508; 1509) + BLOCK@[1509; 1512) + L_CURLY@[1509; 1510) + WHITESPACE@[1510; 1511) + R_CURLY@[1511; 1512) + WHITESPACE@[1512; 1513) + R_CURLY@[1513; 1514) + WHITESPACE@[1514; 1519) + LET_STMT@[1519; 1533) + LET_KW@[1519; 1522) + WHITESPACE@[1522; 1523) + BIND_PAT@[1523; 1528) + MUT_KW@[1523; 1526) + WHITESPACE@[1526; 1527) + NAME@[1527; 1528) + IDENT@[1527; 1528) "i" + WHITESPACE@[1528; 1529) + EQ@[1529; 1530) + WHITESPACE@[1530; 1531) + LITERAL@[1531; 1532) + INT_NUMBER@[1531; 1532) "0" + SEMI@[1532; 1533) + WHITESPACE@[1533; 1538) + LOOP_EXPR@[1538; 1631) + LOOP_KW@[1538; 1542) + WHITESPACE@[1542; 1543) + BLOCK@[1543; 1631) + L_CURLY@[1543; 1544) + WHITESPACE@[1544; 1545) + EXPR_STMT@[1545; 1552) + BIN_EXPR@[1545; 1551) + PATH_EXPR@[1545; 1546) + PATH@[1545; 1546) + PATH_SEGMENT@[1545; 1546) + NAME_REF@[1545; 1546) + IDENT@[1545; 1546) "i" + WHITESPACE@[1546; 1547) + PLUSEQ@[1547; 1549) + WHITESPACE@[1549; 1550) + LITERAL@[1550; 1551) + INT_NUMBER@[1550; 1551) "1" + SEMI@[1551; 1552) + WHITESPACE@[1552; 1553) + EXPR_STMT@[1553; 1616) + IF_EXPR@[1553; 1616) + IF_KW@[1553; 1555) + WHITESPACE@[1555; 1556) + CONDITION@[1556; 1562) + BIN_EXPR@[1556; 1562) + PATH_EXPR@[1556; 1557) + PATH@[1556; 1557) + PATH_SEGMENT@[1556; 1557) + NAME_REF@[1556; 1557) + IDENT@[1556; 1557) "i" + WHITESPACE@[1557; 1558) + EQEQ@[1558; 1560) + WHITESPACE@[1560; 1561) + LITERAL@[1561; 1562) + INT_NUMBER@[1561; 1562) "1" + WHITESPACE@[1562; 1563) + BLOCK@[1563; 1616) + L_CURLY@[1563; 1564) + WHITESPACE@[1564; 1565) + MATCH_EXPR@[1565; 1614) + MATCH_KW@[1565; 1570) + WHITESPACE@[1570; 1571) + PAREN_EXPR@[1571; 1581) + L_PAREN@[1571; 1572) + CONTINUE_EXPR@[1572; 1580) + CONTINUE_KW@[1572; 1580) + R_PAREN@[1580; 1581) + WHITESPACE@[1581; 1582) + MATCH_ARM_LIST@[1582; 1614) + L_CURLY@[1582; 1583) + WHITESPACE@[1583; 1584) + MATCH_ARM@[1584; 1592) + LITERAL@[1584; 1585) + INT_NUMBER@[1584; 1585) "1" + WHITESPACE@[1585; 1586) + FAT_ARROW@[1586; 1588) + WHITESPACE@[1588; 1589) + BLOCK_EXPR@[1589; 1592) + BLOCK@[1589; 1592) + L_CURLY@[1589; 1590) + WHITESPACE@[1590; 1591) + R_CURLY@[1591; 1592) + COMMA@[1592; 1593) + WHITESPACE@[1593; 1594) + MATCH_ARM@[1594; 1612) + PLACEHOLDER_PAT@[1594; 1595) + UNDERSCORE@[1594; 1595) + WHITESPACE@[1595; 1596) + FAT_ARROW@[1596; 1598) + WHITESPACE@[1598; 1599) + MACRO_CALL@[1599; 1612) + PATH@[1599; 1604) + PATH_SEGMENT@[1599; 1604) + NAME_REF@[1599; 1604) + IDENT@[1599; 1604) "panic" + EXCL@[1604; 1605) + TOKEN_TREE@[1605; 1612) + L_PAREN@[1605; 1606) + STRING@[1606; 1611) + R_PAREN@[1611; 1612) + WHITESPACE@[1612; 1613) + R_CURLY@[1613; 1614) + WHITESPACE@[1614; 1615) + R_CURLY@[1615; 1616) + WHITESPACE@[1616; 1623) + EXPR_STMT@[1623; 1629) + BREAK_EXPR@[1623; 1628) + BREAK_KW@[1623; 1628) + SEMI@[1628; 1629) + WHITESPACE@[1629; 1630) + R_CURLY@[1630; 1631) + WHITESPACE@[1631; 1632) + R_CURLY@[1632; 1633) + WHITESPACE@[1633; 1635) + FN_DEF@[1635; 1689) + FN_KW@[1635; 1637) + WHITESPACE@[1637; 1638) + NAME@[1638; 1650) + IDENT@[1638; 1650) "evil_lincoln" + PARAM_LIST@[1650; 1652) + L_PAREN@[1650; 1651) + R_PAREN@[1651; 1652) + WHITESPACE@[1652; 1653) + BLOCK@[1653; 1689) + L_CURLY@[1653; 1654) + WHITESPACE@[1654; 1655) + LET_STMT@[1655; 1687) + LET_KW@[1655; 1658) + WHITESPACE@[1658; 1659) + BIND_PAT@[1659; 1664) + NAME@[1659; 1664) + IDENT@[1659; 1664) "_evil" + WHITESPACE@[1664; 1665) + EQ@[1665; 1666) + WHITESPACE@[1666; 1667) + MACRO_CALL@[1667; 1686) + PATH@[1667; 1674) + PATH_SEGMENT@[1667; 1674) + NAME_REF@[1667; 1674) + IDENT@[1667; 1674) "println" + EXCL@[1674; 1675) + TOKEN_TREE@[1675; 1686) + L_PAREN@[1675; 1676) + STRING@[1676; 1685) + R_PAREN@[1685; 1686) + SEMI@[1686; 1687) + WHITESPACE@[1687; 1688) + R_CURLY@[1688; 1689) + WHITESPACE@[1689; 1691) + FN_DEF@[1691; 1927) + FN_KW@[1691; 1693) + WHITESPACE@[1693; 1694) + NAME@[1694; 1698) + IDENT@[1694; 1698) "dots" + PARAM_LIST@[1698; 1700) + L_PAREN@[1698; 1699) + R_PAREN@[1699; 1700) + WHITESPACE@[1700; 1701) + BLOCK@[1701; 1927) + L_CURLY@[1701; 1702) + WHITESPACE@[1702; 1707) + EXPR_STMT@[1707; 1925) + MACRO_CALL@[1707; 1924) + PATH@[1707; 1716) + PATH_SEGMENT@[1707; 1716) + NAME_REF@[1707; 1716) + IDENT@[1707; 1716) "assert_eq" + EXCL@[1716; 1717) + TOKEN_TREE@[1717; 1924) + L_PAREN@[1717; 1718) + IDENT@[1718; 1724) "String" + COLONCOLON@[1724; 1726) + IDENT@[1726; 1730) "from" + TOKEN_TREE@[1730; 1784) + L_PAREN@[1730; 1731) + STRING@[1731; 1783) + R_PAREN@[1783; 1784) + COMMA@[1784; 1785) + WHITESPACE@[1785; 1801) + IDENT@[1801; 1807) "format" + EXCL@[1807; 1808) + TOKEN_TREE@[1808; 1923) + L_PAREN@[1808; 1809) + STRING@[1809; 1815) + COMMA@[1815; 1816) + WHITESPACE@[1816; 1817) + DOTDOT@[1817; 1819) + WHITESPACE@[1819; 1820) + DOTDOT@[1820; 1822) + WHITESPACE@[1822; 1823) + DOTDOT@[1823; 1825) + WHITESPACE@[1825; 1826) + DOTDOT@[1826; 1828) + WHITESPACE@[1828; 1829) + DOTDOT@[1829; 1831) + WHITESPACE@[1831; 1832) + DOTDOT@[1832; 1834) + WHITESPACE@[1834; 1835) + DOTDOT@[1835; 1837) + WHITESPACE@[1837; 1838) + DOTDOT@[1838; 1840) + WHITESPACE@[1840; 1841) + DOTDOT@[1841; 1843) + WHITESPACE@[1843; 1844) + DOTDOT@[1844; 1846) + WHITESPACE@[1846; 1847) + DOTDOT@[1847; 1849) + WHITESPACE@[1849; 1850) + DOTDOT@[1850; 1852) + WHITESPACE@[1852; 1853) + DOTDOT@[1853; 1855) + WHITESPACE@[1855; 1887) + DOTDOT@[1887; 1889) + WHITESPACE@[1889; 1890) + DOTDOT@[1890; 1892) + WHITESPACE@[1892; 1893) + DOTDOT@[1893; 1895) + WHITESPACE@[1895; 1896) + DOTDOT@[1896; 1898) + WHITESPACE@[1898; 1899) + DOTDOT@[1899; 1901) + WHITESPACE@[1901; 1902) + DOTDOT@[1902; 1904) + WHITESPACE@[1904; 1905) + DOTDOT@[1905; 1907) + WHITESPACE@[1907; 1908) + DOTDOT@[1908; 1910) + WHITESPACE@[1910; 1911) + DOTDOT@[1911; 1913) + WHITESPACE@[1913; 1914) + DOTDOT@[1914; 1916) + WHITESPACE@[1916; 1917) + DOTDOT@[1917; 1919) + WHITESPACE@[1919; 1920) + DOTDOT@[1920; 1922) + R_PAREN@[1922; 1923) + R_PAREN@[1923; 1924) + SEMI@[1924; 1925) + WHITESPACE@[1925; 1926) + R_CURLY@[1926; 1927) + WHITESPACE@[1927; 1929) + FN_DEF@[1929; 2422) + FN_KW@[1929; 1931) + WHITESPACE@[1931; 1932) + NAME@[1932; 1934) + IDENT@[1932; 1934) "u8" + PARAM_LIST@[1934; 1942) + L_PAREN@[1934; 1935) + PARAM@[1935; 1941) + BIND_PAT@[1935; 1937) + NAME@[1935; 1937) + IDENT@[1935; 1937) "u8" + COLON@[1937; 1938) + WHITESPACE@[1938; 1939) + PATH_TYPE@[1939; 1941) + PATH@[1939; 1941) + PATH_SEGMENT@[1939; 1941) + NAME_REF@[1939; 1941) + IDENT@[1939; 1941) "u8" + R_PAREN@[1941; 1942) + WHITESPACE@[1942; 1943) + BLOCK@[1943; 2422) + L_CURLY@[1943; 1944) + WHITESPACE@[1944; 1949) + IF_EXPR@[1949; 2420) + IF_KW@[1949; 1951) + WHITESPACE@[1951; 1952) + CONDITION@[1952; 1961) + BIN_EXPR@[1952; 1961) + PATH_EXPR@[1952; 1954) + PATH@[1952; 1954) + PATH_SEGMENT@[1952; 1954) + NAME_REF@[1952; 1954) + IDENT@[1952; 1954) "u8" + WHITESPACE@[1954; 1955) + NEQ@[1955; 1957) + WHITESPACE@[1957; 1958) + LITERAL@[1958; 1961) + INT_NUMBER@[1958; 1961) "0u8" + WHITESPACE@[1961; 1962) + BLOCK@[1962; 2420) + L_CURLY@[1962; 1963) + WHITESPACE@[1963; 1972) + EXPR_STMT@[1972; 2414) + MACRO_CALL@[1972; 2413) + PATH@[1972; 1981) + PATH_SEGMENT@[1972; 1981) + NAME_REF@[1972; 1981) + IDENT@[1972; 1981) "assert_eq" + EXCL@[1981; 1982) + TOKEN_TREE@[1982; 2413) + L_PAREN@[1982; 1983) + INT_NUMBER@[1983; 1986) "8u8" + COMMA@[1986; 1987) + WHITESPACE@[1987; 1988) + TOKEN_TREE@[1988; 2412) + L_CURLY@[1988; 1989) + WHITESPACE@[1989; 2002) + IDENT@[2002; 2013) "macro_rules" + EXCL@[2013; 2014) + WHITESPACE@[2014; 2015) + IDENT@[2015; 2017) "u8" + WHITESPACE@[2017; 2018) + TOKEN_TREE@[2018; 2296) + L_CURLY@[2018; 2019) + WHITESPACE@[2019; 2036) + TOKEN_TREE@[2036; 2040) + L_PAREN@[2036; 2037) + IDENT@[2037; 2039) "u8" + R_PAREN@[2039; 2040) + WHITESPACE@[2040; 2041) + FAT_ARROW@[2041; 2043) + WHITESPACE@[2043; 2044) + TOKEN_TREE@[2044; 2281) + L_CURLY@[2044; 2045) + WHITESPACE@[2045; 2066) + MOD_KW@[2066; 2069) + WHITESPACE@[2069; 2070) + IDENT@[2070; 2072) "u8" + WHITESPACE@[2072; 2073) + TOKEN_TREE@[2073; 2263) + L_CURLY@[2073; 2074) + WHITESPACE@[2074; 2099) + PUB_KW@[2099; 2102) + WHITESPACE@[2102; 2103) + FN_KW@[2103; 2105) + WHITESPACE@[2105; 2106) + IDENT@[2106; 2108) "u8" + L_ANGLE@[2108; 2109) + LIFETIME@[2109; 2112) "'u8" + COLON@[2112; 2113) + WHITESPACE@[2113; 2114) + LIFETIME@[2114; 2117) "'u8" + WHITESPACE@[2117; 2118) + PLUS@[2118; 2119) + WHITESPACE@[2119; 2120) + LIFETIME@[2120; 2123) "'u8" + R_ANGLE@[2123; 2124) + TOKEN_TREE@[2124; 2137) + L_PAREN@[2124; 2125) + IDENT@[2125; 2127) "u8" + COLON@[2127; 2128) + WHITESPACE@[2128; 2129) + AMP@[2129; 2130) + LIFETIME@[2130; 2133) "'u8" + WHITESPACE@[2133; 2134) + IDENT@[2134; 2136) "u8" + R_PAREN@[2136; 2137) + WHITESPACE@[2137; 2138) + THIN_ARROW@[2138; 2140) + WHITESPACE@[2140; 2141) + AMP@[2141; 2142) + LIFETIME@[2142; 2145) "'u8" + WHITESPACE@[2145; 2146) + IDENT@[2146; 2148) "u8" + WHITESPACE@[2148; 2149) + TOKEN_TREE@[2149; 2241) + L_CURLY@[2149; 2150) + WHITESPACE@[2150; 2179) + STRING@[2179; 2183) + SEMI@[2183; 2184) + WHITESPACE@[2184; 2213) + IDENT@[2213; 2215) "u8" + WHITESPACE@[2215; 2240) + R_CURLY@[2240; 2241) + WHITESPACE@[2241; 2262) + R_CURLY@[2262; 2263) + WHITESPACE@[2263; 2280) + R_CURLY@[2280; 2281) + SEMI@[2281; 2282) + WHITESPACE@[2282; 2295) + R_CURLY@[2295; 2296) + WHITESPACE@[2296; 2310) + IDENT@[2310; 2312) "u8" + EXCL@[2312; 2313) + TOKEN_TREE@[2313; 2317) + L_PAREN@[2313; 2314) + IDENT@[2314; 2316) "u8" + R_PAREN@[2316; 2317) + SEMI@[2317; 2318) + WHITESPACE@[2318; 2331) + LET_KW@[2331; 2334) + WHITESPACE@[2334; 2335) + AMP@[2335; 2336) + IDENT@[2336; 2338) "u8" + COLON@[2338; 2339) + WHITESPACE@[2339; 2340) + AMP@[2340; 2341) + IDENT@[2341; 2343) "u8" + WHITESPACE@[2343; 2344) + EQ@[2344; 2345) + WHITESPACE@[2345; 2346) + IDENT@[2346; 2348) "u8" + COLONCOLON@[2348; 2350) + IDENT@[2350; 2352) "u8" + TOKEN_TREE@[2352; 2358) + L_PAREN@[2352; 2353) + AMP@[2353; 2354) + INT_NUMBER@[2354; 2357) "8u8" + R_PAREN@[2357; 2358) + SEMI@[2358; 2359) + WHITESPACE@[2359; 2372) + CRATE_KW@[2372; 2377) + COLONCOLON@[2377; 2379) + IDENT@[2379; 2381) "u8" + TOKEN_TREE@[2381; 2386) + L_PAREN@[2381; 2382) + INT_NUMBER@[2382; 2385) "0u8" + R_PAREN@[2385; 2386) + SEMI@[2386; 2387) + WHITESPACE@[2387; 2400) + IDENT@[2400; 2402) "u8" + WHITESPACE@[2402; 2411) + R_CURLY@[2411; 2412) + R_PAREN@[2412; 2413) + SEMI@[2413; 2414) + WHITESPACE@[2414; 2419) + R_CURLY@[2419; 2420) + WHITESPACE@[2420; 2421) + R_CURLY@[2421; 2422) + WHITESPACE@[2422; 2424) + FN_DEF@[2424; 2561) + FN_KW@[2424; 2426) + WHITESPACE@[2426; 2427) + NAME@[2427; 2432) + IDENT@[2427; 2432) "fishy" + PARAM_LIST@[2432; 2434) + L_PAREN@[2432; 2433) + R_PAREN@[2433; 2434) + WHITESPACE@[2434; 2435) + BLOCK@[2435; 2561) + L_CURLY@[2435; 2436) + WHITESPACE@[2436; 2441) + EXPR_STMT@[2441; 2559) + MACRO_CALL@[2441; 2558) + PATH@[2441; 2450) + PATH_SEGMENT@[2441; 2450) + NAME_REF@[2441; 2450) + IDENT@[2441; 2450) "assert_eq" + EXCL@[2450; 2451) + TOKEN_TREE@[2451; 2558) + L_PAREN@[2451; 2452) + IDENT@[2452; 2458) "String" + COLONCOLON@[2458; 2460) + IDENT@[2460; 2464) "from" + TOKEN_TREE@[2464; 2471) + L_PAREN@[2464; 2465) + STRING@[2465; 2470) + R_PAREN@[2470; 2471) + COMMA@[2471; 2472) + WHITESPACE@[2472; 2488) + IDENT@[2488; 2494) "String" + COLONCOLON@[2494; 2496) + L_ANGLE@[2496; 2497) + R_ANGLE@[2497; 2498) + COLONCOLON@[2498; 2500) + IDENT@[2500; 2504) "from" + COLONCOLON@[2504; 2506) + L_ANGLE@[2506; 2507) + R_ANGLE@[2507; 2508) + TOKEN_TREE@[2508; 2515) + L_PAREN@[2508; 2509) + STRING@[2509; 2514) + R_PAREN@[2514; 2515) + DOT@[2515; 2516) + IDENT@[2516; 2521) "chars" + COLONCOLON@[2521; 2523) + L_ANGLE@[2523; 2524) + R_ANGLE@[2524; 2525) + TOKEN_TREE@[2525; 2527) + L_PAREN@[2525; 2526) + R_PAREN@[2526; 2527) + DOT@[2527; 2528) + IDENT@[2528; 2531) "rev" + COLONCOLON@[2531; 2533) + L_ANGLE@[2533; 2534) + R_ANGLE@[2534; 2535) + TOKEN_TREE@[2535; 2537) + L_PAREN@[2535; 2536) + R_PAREN@[2536; 2537) + DOT@[2537; 2538) + IDENT@[2538; 2545) "collect" + COLONCOLON@[2545; 2547) + L_ANGLE@[2547; 2548) + IDENT@[2548; 2554) "String" + R_ANGLE@[2554; 2555) + TOKEN_TREE@[2555; 2557) + L_PAREN@[2555; 2556) + R_PAREN@[2556; 2557) + R_PAREN@[2557; 2558) + SEMI@[2558; 2559) + WHITESPACE@[2559; 2560) + R_CURLY@[2560; 2561) + WHITESPACE@[2561; 2563) + FN_DEF@[2563; 2635) + FN_KW@[2563; 2565) + WHITESPACE@[2565; 2566) + NAME@[2566; 2571) + IDENT@[2566; 2571) "union" + PARAM_LIST@[2571; 2573) + L_PAREN@[2571; 2572) + R_PAREN@[2572; 2573) + WHITESPACE@[2573; 2574) + BLOCK@[2574; 2635) + L_CURLY@[2574; 2575) + WHITESPACE@[2575; 2580) + STRUCT_DEF@[2580; 2633) + UNION_KW@[2580; 2585) + WHITESPACE@[2585; 2586) + NAME@[2586; 2591) + IDENT@[2586; 2591) "union" + TYPE_PARAM_LIST@[2591; 2599) + L_ANGLE@[2591; 2592) + LIFETIME_PARAM@[2592; 2598) + LIFETIME@[2592; 2598) "'union" + R_ANGLE@[2598; 2599) + WHITESPACE@[2599; 2600) + NAMED_FIELD_DEF_LIST@[2600; 2633) + L_CURLY@[2600; 2601) + WHITESPACE@[2601; 2602) + NAMED_FIELD_DEF@[2602; 2630) + NAME@[2602; 2607) + IDENT@[2602; 2607) "union" + COLON@[2607; 2608) + WHITESPACE@[2608; 2609) + REFERENCE_TYPE@[2609; 2630) + AMP@[2609; 2610) + LIFETIME@[2610; 2616) "'union" + WHITESPACE@[2616; 2617) + PATH_TYPE@[2617; 2630) + PATH@[2617; 2630) + PATH_SEGMENT@[2617; 2630) + NAME_REF@[2617; 2622) + IDENT@[2617; 2622) "union" + TYPE_ARG_LIST@[2622; 2630) + L_ANGLE@[2622; 2623) + LIFETIME_ARG@[2623; 2629) + LIFETIME@[2623; 2629) "'union" + R_ANGLE@[2629; 2630) + COMMA@[2630; 2631) + WHITESPACE@[2631; 2632) + R_CURLY@[2632; 2633) + WHITESPACE@[2633; 2634) + R_CURLY@[2634; 2635) + WHITESPACE@[2635; 2637) + FN_DEF@[2637; 2771) + FN_KW@[2637; 2639) + WHITESPACE@[2639; 2640) + NAME@[2640; 2658) + IDENT@[2640; 2658) "special_characters" + PARAM_LIST@[2658; 2660) + L_PAREN@[2658; 2659) + R_PAREN@[2659; 2660) + WHITESPACE@[2660; 2661) + BLOCK@[2661; 2771) + L_CURLY@[2661; 2662) + WHITESPACE@[2662; 2667) + LET_STMT@[2667; 2750) + LET_KW@[2667; 2670) + WHITESPACE@[2670; 2671) + BIND_PAT@[2671; 2674) + NAME@[2671; 2674) + IDENT@[2671; 2674) "val" + WHITESPACE@[2674; 2675) + EQ@[2675; 2676) + WHITESPACE@[2676; 2677) + PREFIX_EXPR@[2677; 2742) + EXCL@[2677; 2678) + PAREN_EXPR@[2678; 2742) + L_PAREN@[2678; 2679) + BIN_EXPR@[2679; 2741) + CALL_EXPR@[2679; 2724) + PAREN_EXPR@[2679; 2700) + L_PAREN@[2679; 2680) + LAMBDA_EXPR@[2680; 2699) + PARAM_LIST@[2680; 2697) + PIPE@[2680; 2681) + PARAM@[2681; 2691) + TUPLE_PAT@[2681; 2685) + L_PAREN@[2681; 2682) + DOTDOT@[2682; 2684) + R_PAREN@[2684; 2685) + COLON@[2685; 2686) + TUPLE_TYPE@[2686; 2691) + L_PAREN@[2686; 2687) + PLACEHOLDER_TYPE@[2687; 2688) + UNDERSCORE@[2687; 2688) + COMMA@[2688; 2689) + PLACEHOLDER_TYPE@[2689; 2690) + UNDERSCORE@[2689; 2690) + R_PAREN@[2690; 2691) + COMMA@[2691; 2692) + PARAM@[2692; 2696) + BIND_PAT@[2692; 2696) + NAME@[2692; 2694) + IDENT@[2692; 2694) "__" + AT@[2694; 2695) + PLACEHOLDER_PAT@[2695; 2696) + UNDERSCORE@[2695; 2696) + PIPE@[2696; 2697) + PATH_EXPR@[2697; 2699) + PATH@[2697; 2699) + PATH_SEGMENT@[2697; 2699) + NAME_REF@[2697; 2699) + IDENT@[2697; 2699) "__" + R_PAREN@[2699; 2700) + ARG_LIST@[2700; 2724) + L_PAREN@[2700; 2701) + TUPLE_EXPR@[2701; 2716) + L_PAREN@[2701; 2702) + REF_EXPR@[2702; 2708) + AMP@[2702; 2703) + PREFIX_EXPR@[2703; 2708) + STAR@[2703; 2704) + LITERAL@[2704; 2708) + STRING@[2704; 2708) + COMMA@[2708; 2709) + LITERAL@[2709; 2715) + CHAR@[2709; 2715) + R_PAREN@[2715; 2716) + COMMENT@[2716; 2720) + COMMA@[2720; 2721) + BLOCK_EXPR@[2721; 2723) + BLOCK@[2721; 2723) + L_CURLY@[2721; 2722) + R_CURLY@[2722; 2723) + R_PAREN@[2723; 2724) + EQEQ@[2724; 2726) + BLOCK_EXPR@[2726; 2741) + BLOCK@[2726; 2741) + L_CURLY@[2726; 2727) + EXPR_STMT@[2727; 2740) + REF_EXPR@[2727; 2739) + AMP@[2727; 2728) + INDEX_EXPR@[2728; 2739) + ARRAY_EXPR@[2728; 2735) + L_BRACK@[2728; 2729) + RANGE_EXPR@[2729; 2734) + DOTDOTEQ@[2729; 2732) + RANGE_EXPR@[2732; 2734) + DOTDOT@[2732; 2734) + R_BRACK@[2734; 2735) + L_BRACK@[2735; 2736) + RANGE_EXPR@[2736; 2738) + DOTDOT@[2736; 2738) + R_BRACK@[2738; 2739) + SEMI@[2739; 2740) + R_CURLY@[2740; 2741) + R_PAREN@[2741; 2742) + COMMENT@[2742; 2744) + WHITESPACE@[2744; 2749) + SEMI@[2749; 2750) + WHITESPACE@[2750; 2755) + EXPR_STMT@[2755; 2769) + MACRO_CALL@[2755; 2768) + PATH@[2755; 2761) + PATH_SEGMENT@[2755; 2761) + NAME_REF@[2755; 2761) + IDENT@[2755; 2761) "assert" + EXCL@[2761; 2762) + TOKEN_TREE@[2762; 2768) + L_PAREN@[2762; 2763) + EXCL@[2763; 2764) + IDENT@[2764; 2767) "val" + R_PAREN@[2767; 2768) + SEMI@[2768; 2769) + WHITESPACE@[2769; 2770) + R_CURLY@[2770; 2771) + WHITESPACE@[2771; 2773) + FN_DEF@[2773; 3243) + FN_KW@[2773; 2775) + WHITESPACE@[2775; 2776) + NAME@[2776; 2786) + IDENT@[2776; 2786) "punch_card" + PARAM_LIST@[2786; 2788) + L_PAREN@[2786; 2787) + R_PAREN@[2787; 2788) + WHITESPACE@[2788; 2789) + RET_TYPE@[2789; 2812) + THIN_ARROW@[2789; 2791) + WHITESPACE@[2791; 2792) + IMPL_TRAIT_TYPE@[2792; 2812) + IMPL_KW@[2792; 2796) + WHITESPACE@[2796; 2797) + PATH_TYPE@[2797; 2812) + PATH@[2797; 2812) + PATH@[2797; 2805) + PATH@[2797; 2800) + PATH_SEGMENT@[2797; 2800) + NAME_REF@[2797; 2800) + IDENT@[2797; 2800) "std" + COLONCOLON@[2800; 2802) + PATH_SEGMENT@[2802; 2805) + NAME_REF@[2802; 2805) + IDENT@[2802; 2805) "fmt" + COLONCOLON@[2805; 2807) + PATH_SEGMENT@[2807; 2812) + NAME_REF@[2807; 2812) + IDENT@[2807; 2812) "Debug" + WHITESPACE@[2812; 2813) + BLOCK@[2813; 3243) + L_CURLY@[2813; 2814) + WHITESPACE@[2814; 2819) + RANGE_EXPR@[2819; 3241) + DOTDOTEQ@[2819; 2822) + RANGE_EXPR@[2822; 3241) + DOTDOTEQ@[2822; 2825) + RANGE_EXPR@[2825; 3241) + DOTDOT@[2825; 2827) + WHITESPACE@[2827; 2828) + RANGE_EXPR@[2828; 3241) + DOTDOT@[2828; 2830) + WHITESPACE@[2830; 2834) + RANGE_EXPR@[2834; 3241) + DOTDOT@[2834; 2836) + WHITESPACE@[2836; 2837) + RANGE_EXPR@[2837; 3241) + DOTDOT@[2837; 2839) + WHITESPACE@[2839; 2840) + RANGE_EXPR@[2840; 3241) + DOTDOT@[2840; 2842) + WHITESPACE@[2842; 2843) + RANGE_EXPR@[2843; 3241) + DOTDOT@[2843; 2845) + WHITESPACE@[2845; 2849) + RANGE_EXPR@[2849; 3241) + DOTDOT@[2849; 2851) + WHITESPACE@[2851; 2852) + RANGE_EXPR@[2852; 3241) + DOTDOT@[2852; 2854) + WHITESPACE@[2854; 2855) + RANGE_EXPR@[2855; 3241) + DOTDOT@[2855; 2857) + WHITESPACE@[2857; 2858) + RANGE_EXPR@[2858; 3241) + DOTDOT@[2858; 2860) + WHITESPACE@[2860; 2864) + RANGE_EXPR@[2864; 3241) + DOTDOT@[2864; 2866) + WHITESPACE@[2866; 2867) + RANGE_EXPR@[2867; 3241) + DOTDOTEQ@[2867; 2870) + RANGE_EXPR@[2870; 3241) + DOTDOT@[2870; 2872) + WHITESPACE@[2872; 2873) + RANGE_EXPR@[2873; 3241) + DOTDOT@[2873; 2875) + WHITESPACE@[2875; 2880) + RANGE_EXPR@[2880; 3241) + DOTDOTEQ@[2880; 2883) + RANGE_EXPR@[2883; 3241) + DOTDOT@[2883; 2885) + WHITESPACE@[2885; 2886) + RANGE_EXPR@[2886; 3241) + DOTDOTEQ@[2886; 2889) + RANGE_EXPR@[2889; 3241) + DOTDOT@[2889; 2891) + WHITESPACE@[2891; 2895) + RANGE_EXPR@[2895; 3241) + DOTDOT@[2895; 2897) + WHITESPACE@[2897; 2898) + RANGE_EXPR@[2898; 3241) + DOTDOT@[2898; 2900) + WHITESPACE@[2900; 2901) + RANGE_EXPR@[2901; 3241) + DOTDOT@[2901; 2903) + WHITESPACE@[2903; 2904) + RANGE_EXPR@[2904; 3241) + DOTDOT@[2904; 2906) + WHITESPACE@[2906; 2910) + RANGE_EXPR@[2910; 3241) + DOTDOT@[2910; 2912) + WHITESPACE@[2912; 2913) + RANGE_EXPR@[2913; 3241) + DOTDOT@[2913; 2915) + WHITESPACE@[2915; 2916) + RANGE_EXPR@[2916; 3241) + DOTDOT@[2916; 2918) + WHITESPACE@[2918; 2919) + RANGE_EXPR@[2919; 3241) + DOTDOT@[2919; 2921) + WHITESPACE@[2921; 2925) + RANGE_EXPR@[2925; 3241) + DOTDOTEQ@[2925; 2928) + RANGE_EXPR@[2928; 3241) + DOTDOTEQ@[2928; 2931) + RANGE_EXPR@[2931; 3241) + DOTDOTEQ@[2931; 2934) + RANGE_EXPR@[2934; 3241) + DOTDOT@[2934; 2936) + WHITESPACE@[2936; 2941) + RANGE_EXPR@[2941; 3241) + DOTDOTEQ@[2941; 2944) + RANGE_EXPR@[2944; 3241) + DOTDOT@[2944; 2946) + WHITESPACE@[2946; 2947) + RANGE_EXPR@[2947; 3241) + DOTDOTEQ@[2947; 2950) + RANGE_EXPR@[2950; 3241) + DOTDOT@[2950; 2952) + WHITESPACE@[2952; 2956) + RANGE_EXPR@[2956; 3241) + DOTDOTEQ@[2956; 2959) + RANGE_EXPR@[2959; 3241) + DOTDOT@[2959; 2961) + WHITESPACE@[2961; 2962) + RANGE_EXPR@[2962; 3241) + DOTDOTEQ@[2962; 2965) + RANGE_EXPR@[2965; 3241) + DOTDOT@[2965; 2967) + WHITESPACE@[2967; 2971) + RANGE_EXPR@[2971; 3241) + DOTDOT@[2971; 2973) + WHITESPACE@[2973; 2974) + RANGE_EXPR@[2974; 3241) + DOTDOTEQ@[2974; 2977) + RANGE_EXPR@[2977; 3241) + DOTDOTEQ@[2977; 2980) + RANGE_EXPR@[2980; 3241) + DOTDOT@[2980; 2982) + WHITESPACE@[2982; 2986) + RANGE_EXPR@[2986; 3241) + DOTDOT@[2986; 2988) + WHITESPACE@[2988; 2989) + RANGE_EXPR@[2989; 3241) + DOTDOTEQ@[2989; 2992) + RANGE_EXPR@[2992; 3241) + DOTDOT@[2992; 2994) + WHITESPACE@[2994; 2995) + RANGE_EXPR@[2995; 3241) + DOTDOT@[2995; 2997) + WHITESPACE@[2997; 3002) + RANGE_EXPR@[3002; 3241) + DOTDOTEQ@[3002; 3005) + RANGE_EXPR@[3005; 3241) + DOTDOTEQ@[3005; 3008) + RANGE_EXPR@[3008; 3241) + DOTDOT@[3008; 3010) + WHITESPACE@[3010; 3011) + RANGE_EXPR@[3011; 3241) + DOTDOT@[3011; 3013) + WHITESPACE@[3013; 3017) + RANGE_EXPR@[3017; 3241) + DOTDOTEQ@[3017; 3020) + RANGE_EXPR@[3020; 3241) + DOTDOT@[3020; 3022) + WHITESPACE@[3022; 3023) + RANGE_EXPR@[3023; 3241) + DOTDOTEQ@[3023; 3026) + RANGE_EXPR@[3026; 3241) + DOTDOT@[3026; 3028) + WHITESPACE@[3028; 3032) + RANGE_EXPR@[3032; 3241) + DOTDOTEQ@[3032; 3035) + RANGE_EXPR@[3035; 3241) + DOTDOT@[3035; 3037) + WHITESPACE@[3037; 3038) + RANGE_EXPR@[3038; 3241) + DOTDOT@[3038; 3040) + WHITESPACE@[3040; 3041) + RANGE_EXPR@[3041; 3241) + DOTDOT@[3041; 3043) + WHITESPACE@[3043; 3047) + RANGE_EXPR@[3047; 3241) + DOTDOT@[3047; 3049) + WHITESPACE@[3049; 3050) + RANGE_EXPR@[3050; 3241) + DOTDOTEQ@[3050; 3053) + RANGE_EXPR@[3053; 3241) + DOTDOT@[3053; 3055) + WHITESPACE@[3055; 3056) + RANGE_EXPR@[3056; 3241) + DOTDOT@[3056; 3058) + WHITESPACE@[3058; 3063) + RANGE_EXPR@[3063; 3241) + DOTDOTEQ@[3063; 3066) + RANGE_EXPR@[3066; 3241) + DOTDOT@[3066; 3068) + WHITESPACE@[3068; 3069) + RANGE_EXPR@[3069; 3241) + DOTDOTEQ@[3069; 3072) + RANGE_EXPR@[3072; 3241) + DOTDOT@[3072; 3074) + WHITESPACE@[3074; 3078) + RANGE_EXPR@[3078; 3241) + DOTDOTEQ@[3078; 3081) + RANGE_EXPR@[3081; 3241) + DOTDOT@[3081; 3083) + WHITESPACE@[3083; 3084) + RANGE_EXPR@[3084; 3241) + DOTDOTEQ@[3084; 3087) + RANGE_EXPR@[3087; 3241) + DOTDOT@[3087; 3089) + WHITESPACE@[3089; 3093) + RANGE_EXPR@[3093; 3241) + DOTDOT@[3093; 3095) + WHITESPACE@[3095; 3096) + RANGE_EXPR@[3096; 3241) + DOTDOTEQ@[3096; 3099) + RANGE_EXPR@[3099; 3241) + DOTDOT@[3099; 3101) + WHITESPACE@[3101; 3102) + RANGE_EXPR@[3102; 3241) + DOTDOT@[3102; 3104) + WHITESPACE@[3104; 3108) + RANGE_EXPR@[3108; 3241) + DOTDOT@[3108; 3110) + WHITESPACE@[3110; 3111) + RANGE_EXPR@[3111; 3241) + DOTDOTEQ@[3111; 3114) + RANGE_EXPR@[3114; 3241) + DOTDOT@[3114; 3116) + WHITESPACE@[3116; 3117) + RANGE_EXPR@[3117; 3241) + DOTDOT@[3117; 3119) + WHITESPACE@[3119; 3124) + RANGE_EXPR@[3124; 3241) + DOTDOTEQ@[3124; 3127) + RANGE_EXPR@[3127; 3241) + DOTDOT@[3127; 3129) + WHITESPACE@[3129; 3130) + RANGE_EXPR@[3130; 3241) + DOTDOTEQ@[3130; 3133) + RANGE_EXPR@[3133; 3241) + DOTDOT@[3133; 3135) + WHITESPACE@[3135; 3139) + RANGE_EXPR@[3139; 3241) + DOTDOTEQ@[3139; 3142) + RANGE_EXPR@[3142; 3241) + DOTDOT@[3142; 3144) + WHITESPACE@[3144; 3145) + RANGE_EXPR@[3145; 3241) + DOTDOTEQ@[3145; 3148) + RANGE_EXPR@[3148; 3241) + DOTDOT@[3148; 3150) + WHITESPACE@[3150; 3154) + RANGE_EXPR@[3154; 3241) + DOTDOT@[3154; 3156) + WHITESPACE@[3156; 3157) + RANGE_EXPR@[3157; 3241) + DOTDOT@[3157; 3159) + WHITESPACE@[3159; 3160) + RANGE_EXPR@[3160; 3241) + DOTDOTEQ@[3160; 3163) + RANGE_EXPR@[3163; 3241) + DOTDOT@[3163; 3165) + WHITESPACE@[3165; 3169) + RANGE_EXPR@[3169; 3241) + DOTDOT@[3169; 3171) + WHITESPACE@[3171; 3172) + RANGE_EXPR@[3172; 3241) + DOTDOTEQ@[3172; 3175) + RANGE_EXPR@[3175; 3241) + DOTDOT@[3175; 3177) + WHITESPACE@[3177; 3178) + RANGE_EXPR@[3178; 3241) + DOTDOT@[3178; 3180) + WHITESPACE@[3180; 3185) + RANGE_EXPR@[3185; 3241) + DOTDOTEQ@[3185; 3188) + RANGE_EXPR@[3188; 3241) + DOTDOT@[3188; 3190) + WHITESPACE@[3190; 3191) + RANGE_EXPR@[3191; 3241) + DOTDOTEQ@[3191; 3194) + RANGE_EXPR@[3194; 3241) + DOTDOT@[3194; 3196) + WHITESPACE@[3196; 3200) + RANGE_EXPR@[3200; 3241) + DOTDOT@[3200; 3202) + WHITESPACE@[3202; 3203) + RANGE_EXPR@[3203; 3241) + DOTDOTEQ@[3203; 3206) + RANGE_EXPR@[3206; 3241) + DOTDOTEQ@[3206; 3209) + RANGE_EXPR@[3209; 3241) + DOTDOT@[3209; 3211) + WHITESPACE@[3211; 3215) + RANGE_EXPR@[3215; 3241) + DOTDOTEQ@[3215; 3218) + RANGE_EXPR@[3218; 3241) + DOTDOTEQ@[3218; 3221) + RANGE_EXPR@[3221; 3241) + DOTDOT@[3221; 3223) + WHITESPACE@[3223; 3224) + RANGE_EXPR@[3224; 3241) + DOTDOT@[3224; 3226) + WHITESPACE@[3226; 3230) + RANGE_EXPR@[3230; 3241) + DOTDOT@[3230; 3232) + WHITESPACE@[3232; 3233) + RANGE_EXPR@[3233; 3241) + DOTDOTEQ@[3233; 3236) + RANGE_EXPR@[3236; 3241) + DOTDOT@[3236; 3238) + WHITESPACE@[3238; 3239) + RANGE_EXPR@[3239; 3241) + DOTDOT@[3239; 3241) + WHITESPACE@[3241; 3242) + R_CURLY@[3242; 3243) + WHITESPACE@[3243; 3245) + FN_DEF@[3245; 3281) + FN_KW@[3245; 3247) + WHITESPACE@[3247; 3248) + NAME@[3248; 3254) + IDENT@[3248; 3254) "ktulhu" + PARAM_LIST@[3254; 3256) + L_PAREN@[3254; 3255) + R_PAREN@[3255; 3256) + WHITESPACE@[3256; 3257) + BLOCK@[3257; 3281) + L_CURLY@[3257; 3258) + WHITESPACE@[3258; 3263) + SEMI@[3263; 3264) + SEMI@[3264; 3265) + SEMI@[3265; 3266) + EXPR_STMT@[3266; 3269) + TUPLE_EXPR@[3266; 3268) + L_PAREN@[3266; 3267) + R_PAREN@[3267; 3268) + SEMI@[3268; 3269) + SEMI@[3269; 3270) + SEMI@[3270; 3271) + SEMI@[3271; 3272) + SEMI@[3272; 3273) + SEMI@[3273; 3274) + SEMI@[3274; 3275) + SEMI@[3275; 3276) + SEMI@[3276; 3277) + TUPLE_EXPR@[3277; 3279) + L_PAREN@[3277; 3278) + R_PAREN@[3278; 3279) + WHITESPACE@[3279; 3280) + R_CURLY@[3280; 3281) + WHITESPACE@[3281; 3283) + FN_DEF@[3283; 3541) + VISIBILITY@[3283; 3286) + PUB_KW@[3283; 3286) + WHITESPACE@[3286; 3287) + FN_KW@[3287; 3289) + WHITESPACE@[3289; 3290) + NAME@[3290; 3294) + IDENT@[3290; 3294) "main" + PARAM_LIST@[3294; 3296) + L_PAREN@[3294; 3295) + R_PAREN@[3295; 3296) + WHITESPACE@[3296; 3297) + BLOCK@[3297; 3541) + L_CURLY@[3297; 3298) + WHITESPACE@[3298; 3303) + EXPR_STMT@[3303; 3313) + CALL_EXPR@[3303; 3312) + PATH_EXPR@[3303; 3310) + PATH@[3303; 3310) + PATH_SEGMENT@[3303; 3310) + NAME_REF@[3303; 3310) + IDENT@[3303; 3310) "strange" + ARG_LIST@[3310; 3312) + L_PAREN@[3310; 3311) + R_PAREN@[3311; 3312) + SEMI@[3312; 3313) + WHITESPACE@[3313; 3318) + EXPR_STMT@[3318; 3326) + CALL_EXPR@[3318; 3325) + PATH_EXPR@[3318; 3323) + PATH@[3318; 3323) + PATH_SEGMENT@[3318; 3323) + NAME_REF@[3318; 3323) + IDENT@[3318; 3323) "funny" + ARG_LIST@[3323; 3325) + L_PAREN@[3323; 3324) + R_PAREN@[3324; 3325) + SEMI@[3325; 3326) + WHITESPACE@[3326; 3331) + EXPR_STMT@[3331; 3338) + CALL_EXPR@[3331; 3337) + PATH_EXPR@[3331; 3335) + PATH@[3331; 3335) + PATH_SEGMENT@[3331; 3335) + NAME_REF@[3331; 3335) + IDENT@[3331; 3335) "what" + ARG_LIST@[3335; 3337) + L_PAREN@[3335; 3336) + R_PAREN@[3336; 3337) + SEMI@[3337; 3338) + WHITESPACE@[3338; 3343) + EXPR_STMT@[3343; 3357) + CALL_EXPR@[3343; 3356) + PATH_EXPR@[3343; 3354) + PATH@[3343; 3354) + PATH_SEGMENT@[3343; 3354) + NAME_REF@[3343; 3354) + IDENT@[3343; 3354) "zombiejesus" + ARG_LIST@[3354; 3356) + L_PAREN@[3354; 3355) + R_PAREN@[3355; 3356) + SEMI@[3356; 3357) + WHITESPACE@[3357; 3362) + EXPR_STMT@[3362; 3372) + CALL_EXPR@[3362; 3371) + PATH_EXPR@[3362; 3369) + PATH@[3362; 3369) + PATH_SEGMENT@[3362; 3369) + NAME_REF@[3362; 3369) + IDENT@[3362; 3369) "notsure" + ARG_LIST@[3369; 3371) + L_PAREN@[3369; 3370) + R_PAREN@[3370; 3371) + SEMI@[3371; 3372) + WHITESPACE@[3372; 3377) + EXPR_STMT@[3377; 3393) + CALL_EXPR@[3377; 3392) + PATH_EXPR@[3377; 3390) + PATH@[3377; 3390) + PATH_SEGMENT@[3377; 3390) + NAME_REF@[3377; 3390) + IDENT@[3377; 3390) "canttouchthis" + ARG_LIST@[3390; 3392) + L_PAREN@[3390; 3391) + R_PAREN@[3391; 3392) + SEMI@[3392; 3393) + WHITESPACE@[3393; 3398) + EXPR_STMT@[3398; 3410) + CALL_EXPR@[3398; 3409) + PATH_EXPR@[3398; 3407) + PATH@[3398; 3407) + PATH_SEGMENT@[3398; 3407) + NAME_REF@[3398; 3407) + IDENT@[3398; 3407) "angrydome" + ARG_LIST@[3407; 3409) + L_PAREN@[3407; 3408) + R_PAREN@[3408; 3409) + SEMI@[3409; 3410) + WHITESPACE@[3410; 3415) + EXPR_STMT@[3415; 3430) + CALL_EXPR@[3415; 3429) + PATH_EXPR@[3415; 3427) + PATH@[3415; 3427) + PATH_SEGMENT@[3415; 3427) + NAME_REF@[3415; 3427) + IDENT@[3415; 3427) "evil_lincoln" + ARG_LIST@[3427; 3429) + L_PAREN@[3427; 3428) + R_PAREN@[3428; 3429) + SEMI@[3429; 3430) + WHITESPACE@[3430; 3435) + EXPR_STMT@[3435; 3442) + CALL_EXPR@[3435; 3441) + PATH_EXPR@[3435; 3439) + PATH@[3435; 3439) + PATH_SEGMENT@[3435; 3439) + NAME_REF@[3435; 3439) + IDENT@[3435; 3439) "dots" + ARG_LIST@[3439; 3441) + L_PAREN@[3439; 3440) + R_PAREN@[3440; 3441) + SEMI@[3441; 3442) + WHITESPACE@[3442; 3447) + EXPR_STMT@[3447; 3455) + CALL_EXPR@[3447; 3454) + PATH_EXPR@[3447; 3449) + PATH@[3447; 3449) + PATH_SEGMENT@[3447; 3449) + NAME_REF@[3447; 3449) + IDENT@[3447; 3449) "u8" + ARG_LIST@[3449; 3454) + L_PAREN@[3449; 3450) + LITERAL@[3450; 3453) + INT_NUMBER@[3450; 3453) "8u8" + R_PAREN@[3453; 3454) + SEMI@[3454; 3455) + WHITESPACE@[3455; 3460) + EXPR_STMT@[3460; 3468) + CALL_EXPR@[3460; 3467) + PATH_EXPR@[3460; 3465) + PATH@[3460; 3465) + PATH_SEGMENT@[3460; 3465) + NAME_REF@[3460; 3465) + IDENT@[3460; 3465) "fishy" + ARG_LIST@[3465; 3467) + L_PAREN@[3465; 3466) + R_PAREN@[3466; 3467) + SEMI@[3467; 3468) + WHITESPACE@[3468; 3473) + EXPR_STMT@[3473; 3481) + CALL_EXPR@[3473; 3480) + PATH_EXPR@[3473; 3478) + PATH@[3473; 3478) + PATH_SEGMENT@[3473; 3478) + NAME_REF@[3473; 3478) + IDENT@[3473; 3478) "union" + ARG_LIST@[3478; 3480) + L_PAREN@[3478; 3479) + R_PAREN@[3479; 3480) + SEMI@[3480; 3481) + WHITESPACE@[3481; 3486) + EXPR_STMT@[3486; 3507) + CALL_EXPR@[3486; 3506) + PATH_EXPR@[3486; 3504) + PATH@[3486; 3504) + PATH_SEGMENT@[3486; 3504) + NAME_REF@[3486; 3504) + IDENT@[3486; 3504) "special_characters" + ARG_LIST@[3504; 3506) + L_PAREN@[3504; 3505) + R_PAREN@[3505; 3506) + SEMI@[3506; 3507) + WHITESPACE@[3507; 3512) + EXPR_STMT@[3512; 3525) + CALL_EXPR@[3512; 3524) + PATH_EXPR@[3512; 3522) + PATH@[3512; 3522) + PATH_SEGMENT@[3512; 3522) + NAME_REF@[3512; 3522) + IDENT@[3512; 3522) "punch_card" + ARG_LIST@[3522; 3524) + L_PAREN@[3522; 3523) + R_PAREN@[3523; 3524) + SEMI@[3524; 3525) + WHITESPACE@[3525; 3530) + EXPR_STMT@[3530; 3539) + CALL_EXPR@[3530; 3538) + PATH_EXPR@[3530; 3536) + PATH@[3530; 3536) + PATH_SEGMENT@[3530; 3536) + NAME_REF@[3530; 3536) + IDENT@[3530; 3536) "ktulhu" + ARG_LIST@[3536; 3538) + L_PAREN@[3536; 3537) + R_PAREN@[3537; 3538) + SEMI@[3538; 3539) + WHITESPACE@[3539; 3540) + R_CURLY@[3540; 3541) + WHITESPACE@[3541; 3542) -- cgit v1.2.3