Translate many more binary operators · nandi.uk/gleam@f0e9bd9

+270 -56

compiler-core/src/cranelift/mir.rs

··· 71 71 rhs: Box<Expression>, 72 72 }, 73 73 74 + NotEquals { 75 + lhs: Box<Expression>, 76 + rhs: Box<Expression>, 77 + }, 78 + 79 + IntGt { 80 + lhs: Box<Expression>, 81 + rhs: Box<Expression>, 82 + }, 83 + 84 + IntGtEq { 85 + lhs: Box<Expression>, 86 + rhs: Box<Expression>, 87 + }, 88 + 89 + IntLt { 90 + lhs: Box<Expression>, 91 + rhs: Box<Expression>, 92 + }, 93 + 94 + IntLtEq { 95 + lhs: Box<Expression>, 96 + rhs: Box<Expression>, 97 + }, 98 + 74 99 IntAdd { 75 100 lhs: Box<Expression>, 76 101 rhs: Box<Expression>, ··· 91 116 rhs: Box<Expression>, 92 117 }, 93 118 119 + FloatGt { 120 + lhs: Box<Expression>, 121 + rhs: Box<Expression>, 122 + }, 123 + 124 + FloatGtEq { 125 + lhs: Box<Expression>, 126 + rhs: Box<Expression>, 127 + }, 128 + 129 + FloatLt { 130 + lhs: Box<Expression>, 131 + rhs: Box<Expression>, 132 + }, 133 + 134 + FloatLtEq { 135 + lhs: Box<Expression>, 136 + rhs: Box<Expression>, 137 + }, 138 + 94 139 FloatAdd { 95 140 lhs: Box<Expression>, 96 141 rhs: Box<Expression>, ··· 223 268 | Expression::Float { .. } 224 269 | Expression::Bool { .. } 225 270 | Expression::Equals { .. } 271 + | Expression::NotEquals { .. } 272 + | Expression::IntGt { .. } 273 + | Expression::IntGtEq { .. } 274 + | Expression::IntLt { .. } 275 + | Expression::IntLtEq { .. } 226 276 | Expression::IntAdd { .. } 227 277 | Expression::IntSub { .. } 228 278 | Expression::IntMul { .. } 229 279 | Expression::IntDiv { .. } 280 + | Expression::FloatGt { .. } 281 + | Expression::FloatGtEq { .. } 282 + | Expression::FloatLt { .. } 283 + | Expression::FloatLtEq { .. } 230 284 | Expression::FloatAdd { .. } 231 285 | Expression::FloatSub { .. } 232 286 | Expression::FloatMul { .. } ··· 251 305 lhs: Box::new(Self::flatten_expression(*lhs)), 252 306 rhs: Box::new(Self::flatten_expression(*rhs)), 253 307 }, 308 + Expression::NotEquals { lhs, rhs } => Expression::NotEquals { 309 + lhs: Box::new(Self::flatten_expression(*lhs)), 310 + rhs: Box::new(Self::flatten_expression(*rhs)), 311 + }, 312 + Expression::IntGt { lhs, rhs } => Expression::IntGt { 313 + lhs: Box::new(Self::flatten_expression(*lhs)), 314 + rhs: Box::new(Self::flatten_expression(*rhs)), 315 + }, 316 + Expression::IntGtEq { lhs, rhs } => Expression::IntGtEq { 317 + lhs: Box::new(Self::flatten_expression(*lhs)), 318 + rhs: Box::new(Self::flatten_expression(*rhs)), 319 + }, 320 + Expression::IntLt { lhs, rhs } => Expression::IntLt { 321 + lhs: Box::new(Self::flatten_expression(*lhs)), 322 + rhs: Box::new(Self::flatten_expression(*rhs)), 323 + }, 324 + Expression::IntLtEq { lhs, rhs } => Expression::IntLtEq { 325 + lhs: Box::new(Self::flatten_expression(*lhs)), 326 + rhs: Box::new(Self::flatten_expression(*rhs)), 327 + }, 254 328 Expression::IntAdd { lhs, rhs } => Expression::IntAdd { 255 329 lhs: Box::new(Self::flatten_expression(*lhs)), 256 330 rhs: Box::new(Self::flatten_expression(*rhs)), ··· 267 341 lhs: Box::new(Self::flatten_expression(*lhs)), 268 342 rhs: Box::new(Self::flatten_expression(*rhs)), 269 343 }, 344 + Expression::FloatGt { lhs, rhs } => Expression::FloatGt { 345 + lhs: Box::new(Self::flatten_expression(*lhs)), 346 + rhs: Box::new(Self::flatten_expression(*rhs)), 347 + }, 348 + Expression::FloatGtEq { lhs, rhs } => Expression::FloatGtEq { 349 + lhs: Box::new(Self::flatten_expression(*lhs)), 350 + rhs: Box::new(Self::flatten_expression(*rhs)), 351 + }, 352 + Expression::FloatLt { lhs, rhs } => Expression::FloatLt { 353 + lhs: Box::new(Self::flatten_expression(*lhs)), 354 + rhs: Box::new(Self::flatten_expression(*rhs)), 355 + }, 356 + Expression::FloatLtEq { lhs, rhs } => Expression::FloatLtEq { 357 + lhs: Box::new(Self::flatten_expression(*lhs)), 358 + rhs: Box::new(Self::flatten_expression(*rhs)), 359 + }, 270 360 Expression::FloatAdd { lhs, rhs } => Expression::FloatAdd { 271 361 lhs: Box::new(Self::flatten_expression(*lhs)), 272 362 rhs: Box::new(Self::flatten_expression(*rhs)), ··· 324 414 | Expression::Float { .. } 325 415 | Expression::Bool { .. } 326 416 | Expression::Equals { .. } 417 + | Expression::NotEquals { .. } 418 + | Expression::IntGt { .. } 419 + | Expression::IntGtEq { .. } 420 + | Expression::IntLt { .. } 421 + | Expression::IntLtEq { .. } 327 422 | Expression::IntAdd { .. } 328 423 | Expression::IntSub { .. } 329 424 | Expression::IntMul { .. } 330 425 | Expression::IntDiv { .. } 426 + | Expression::FloatGt { .. } 427 + | Expression::FloatGtEq { .. } 428 + | Expression::FloatLt { .. } 429 + | Expression::FloatLtEq { .. } 331 430 | Expression::FloatAdd { .. } 332 431 | Expression::FloatSub { .. } 333 432 | Expression::FloatMul { .. } ··· 352 451 lhs: Box::new(Self::remove_unused_code(*lhs)), 353 452 rhs: Box::new(Self::remove_unused_code(*rhs)), 354 453 }, 454 + Expression::NotEquals { lhs, rhs } => Expression::NotEquals { 455 + lhs: Box::new(Self::remove_unused_code(*lhs)), 456 + rhs: Box::new(Self::remove_unused_code(*rhs)), 457 + }, 458 + Expression::IntGt { lhs, rhs } => Expression::IntGt { 459 + lhs: Box::new(Self::remove_unused_code(*lhs)), 460 + rhs: Box::new(Self::remove_unused_code(*rhs)), 461 + }, 462 + Expression::IntGtEq { lhs, rhs } => Expression::IntGtEq { 463 + lhs: Box::new(Self::remove_unused_code(*lhs)), 464 + rhs: Box::new(Self::remove_unused_code(*rhs)), 465 + }, 466 + Expression::IntLt { lhs, rhs } => Expression::IntLt { 467 + lhs: Box::new(Self::remove_unused_code(*lhs)), 468 + rhs: Box::new(Self::remove_unused_code(*rhs)), 469 + }, 470 + Expression::IntLtEq { lhs, rhs } => Expression::IntLtEq { 471 + lhs: Box::new(Self::remove_unused_code(*lhs)), 472 + rhs: Box::new(Self::remove_unused_code(*rhs)), 473 + }, 355 474 Expression::IntAdd { lhs, rhs } => Expression::IntAdd { 356 475 lhs: Box::new(Self::remove_unused_code(*lhs)), 357 476 rhs: Box::new(Self::remove_unused_code(*rhs)), ··· 368 487 lhs: Box::new(Self::remove_unused_code(*lhs)), 369 488 rhs: Box::new(Self::remove_unused_code(*rhs)), 370 489 }, 490 + Expression::FloatGt { lhs, rhs } => Expression::FloatGt { 491 + lhs: Box::new(Self::remove_unused_code(*lhs)), 492 + rhs: Box::new(Self::remove_unused_code(*rhs)), 493 + }, 494 + Expression::FloatGtEq { lhs, rhs } => Expression::FloatGtEq { 495 + lhs: Box::new(Self::remove_unused_code(*lhs)), 496 + rhs: Box::new(Self::remove_unused_code(*rhs)), 497 + }, 498 + Expression::FloatLt { lhs, rhs } => Expression::FloatLt { 499 + lhs: Box::new(Self::remove_unused_code(*lhs)), 500 + rhs: Box::new(Self::remove_unused_code(*rhs)), 501 + }, 502 + Expression::FloatLtEq { lhs, rhs } => Expression::FloatLtEq { 503 + lhs: Box::new(Self::remove_unused_code(*lhs)), 504 + rhs: Box::new(Self::remove_unused_code(*rhs)), 505 + }, 371 506 Expression::FloatAdd { lhs, rhs } => Expression::FloatAdd { 372 507 lhs: Box::new(Self::remove_unused_code(*lhs)), 373 508 rhs: Box::new(Self::remove_unused_code(*rhs)), ··· 600 735 else_: rhs, 601 736 }, 602 737 ast::BinOp::Eq => Expression::Equals { lhs, rhs }, 603 - ast::BinOp::NotEq => todo!(), 604 - ast::BinOp::LtInt => todo!(), 605 - ast::BinOp::LtEqInt => todo!(), 606 - ast::BinOp::LtFloat => todo!(), 607 - ast::BinOp::LtEqFloat => todo!(), 608 - ast::BinOp::GtEqInt => todo!(), 609 - ast::BinOp::GtInt => todo!(), 610 - ast::BinOp::GtEqFloat => todo!(), 611 - ast::BinOp::GtFloat => todo!(), 738 + ast::BinOp::NotEq => Expression::NotEquals { lhs, rhs }, 739 + ast::BinOp::LtInt => Expression::IntLt { lhs, rhs }, 740 + ast::BinOp::LtEqInt => Expression::IntLtEq { lhs, rhs }, 741 + ast::BinOp::LtFloat => Expression::FloatLt { lhs, rhs }, 742 + ast::BinOp::LtEqFloat => Expression::FloatLtEq { lhs, rhs }, 743 + ast::BinOp::GtEqInt => Expression::IntGtEq { lhs, rhs }, 744 + ast::BinOp::GtInt => Expression::IntGt { lhs, rhs }, 745 + ast::BinOp::GtEqFloat => Expression::FloatGtEq { lhs, rhs }, 746 + ast::BinOp::GtFloat => Expression::FloatGt { lhs, rhs }, 612 747 ast::BinOp::AddInt => Expression::IntAdd { lhs, rhs }, 613 748 ast::BinOp::AddFloat => Expression::FloatAdd { lhs, rhs }, 614 749 ast::BinOp::SubInt => Expression::IntSub { lhs, rhs }, ··· 708 843 constructor: _, 709 844 arguments: _, 710 845 } => todo!(), 711 - ast::TypedExpr::NegateBool { 712 - location: _, 713 - value: _, 714 - } => todo!(), 715 - ast::TypedExpr::NegateInt { 716 - location: _, 717 - value: _, 718 - } => todo!(), 846 + ast::TypedExpr::NegateBool { location: _, value } => Expression::Equals { 847 + lhs: Box::new(self.translate_expression(value)), 848 + rhs: Box::new(Expression::Bool { value: false }), 849 + }, 850 + ast::TypedExpr::NegateInt { location: _, value } => Expression::IntSub { 851 + lhs: Box::new(Expression::Int { 852 + value: BigInt::from(0), 853 + }), 854 + rhs: Box::new(self.translate_expression(value)), 855 + }, 719 856 ast::TypedExpr::Invalid { 720 857 location: _, 721 858 type_: _, ··· 844 981 845 982 fn translate_guard(&mut self, guard: &ast::TypedClauseGuard) -> Expression { 846 983 match guard { 847 - ast::ClauseGuard::Block { 848 - location: _, 849 - value: _, 850 - } => todo!(), 984 + ast::ClauseGuard::Block { location: _, value } => self.translate_guard(value), 851 985 ast::ClauseGuard::Equals { 852 986 location: _, 853 987 left, ··· 863 997 } 864 998 ast::ClauseGuard::NotEquals { 865 999 location: _, 866 - left: _, 867 - right: _, 868 - } => todo!(), 1000 + left, 1001 + right, 1002 + } => Expression::NotEquals { 1003 + lhs: Box::new(self.translate_guard(left)), 1004 + rhs: Box::new(self.translate_guard(right)), 1005 + }, 869 1006 ast::ClauseGuard::GtInt { 870 1007 location: _, 871 - left: _, 872 - right: _, 873 - } => todo!(), 1008 + left, 1009 + right, 1010 + } => Expression::IntGt { 1011 + lhs: Box::new(self.translate_guard(left)), 1012 + rhs: Box::new(self.translate_guard(right)), 1013 + }, 874 1014 ast::ClauseGuard::GtEqInt { 875 1015 location: _, 876 - left: _, 877 - right: _, 878 - } => todo!(), 1016 + left, 1017 + right, 1018 + } => Expression::IntGtEq { 1019 + lhs: Box::new(self.translate_guard(left)), 1020 + rhs: Box::new(self.translate_guard(right)), 1021 + }, 879 1022 ast::ClauseGuard::LtInt { 880 1023 location: _, 881 - left: _, 882 - right: _, 883 - } => todo!(), 1024 + left, 1025 + right, 1026 + } => Expression::IntLt { 1027 + lhs: Box::new(self.translate_guard(left)), 1028 + rhs: Box::new(self.translate_guard(right)), 1029 + }, 884 1030 ast::ClauseGuard::LtEqInt { 885 1031 location: _, 886 - left: _, 887 - right: _, 888 - } => todo!(), 1032 + left, 1033 + right, 1034 + } => Expression::IntLtEq { 1035 + lhs: Box::new(self.translate_guard(left)), 1036 + rhs: Box::new(self.translate_guard(right)), 1037 + }, 889 1038 ast::ClauseGuard::GtFloat { 890 1039 location: _, 891 - left: _, 892 - right: _, 893 - } => todo!(), 1040 + left, 1041 + right, 1042 + } => Expression::FloatGt { 1043 + lhs: Box::new(self.translate_guard(left)), 1044 + rhs: Box::new(self.translate_guard(right)), 1045 + }, 894 1046 ast::ClauseGuard::GtEqFloat { 895 1047 location: _, 896 - left: _, 897 - right: _, 898 - } => todo!(), 1048 + left, 1049 + right, 1050 + } => Expression::FloatGtEq { 1051 + lhs: Box::new(self.translate_guard(left)), 1052 + rhs: Box::new(self.translate_guard(right)), 1053 + }, 899 1054 ast::ClauseGuard::LtFloat { 900 1055 location: _, 901 - left: _, 902 - right: _, 903 - } => todo!(), 1056 + left, 1057 + right, 1058 + } => Expression::FloatLt { 1059 + lhs: Box::new(self.translate_guard(left)), 1060 + rhs: Box::new(self.translate_guard(right)), 1061 + }, 904 1062 ast::ClauseGuard::LtEqFloat { 905 1063 location: _, 906 - left: _, 907 - right: _, 908 - } => todo!(), 1064 + left, 1065 + right, 1066 + } => Expression::FloatLtEq { 1067 + lhs: Box::new(self.translate_guard(left)), 1068 + rhs: Box::new(self.translate_guard(right)), 1069 + }, 909 1070 ast::ClauseGuard::AddInt { 910 1071 location: _, 911 1072 left, ··· 977 1138 } => todo!(), 978 1139 ast::ClauseGuard::Or { 979 1140 location: _, 980 - left: _, 981 - right: _, 982 - } => todo!(), 1141 + left, 1142 + right, 1143 + } => Expression::If { 1144 + cond: Box::new(self.translate_guard(left)), 1145 + then: Box::new(Expression::Bool { value: true }), 1146 + else_: Box::new(self.translate_guard(right)), 1147 + }, 983 1148 ast::ClauseGuard::And { 984 1149 location: _, 985 - left: _, 986 - right: _, 987 - } => todo!(), 1150 + left, 1151 + right, 1152 + } => Expression::If { 1153 + cond: Box::new(self.translate_guard(left)), 1154 + then: Box::new(self.translate_guard(right)), 1155 + else_: Box::new(Expression::Bool { value: false }), 1156 + }, 988 1157 ast::ClauseGuard::Not { 989 1158 location: _, 990 - expression: _, 991 - } => todo!(), 1159 + expression, 1160 + } => Expression::Equals { 1161 + lhs: Box::new(self.translate_guard(expression)), 1162 + rhs: Box::new(Expression::Bool { value: false }), 1163 + }, 992 1164 ast::ClauseGuard::Var { 993 1165 location: _, 994 1166 type_: _, ··· 1246 1418 r#"pub fn booleans() { 1247 1419 let _ = True 1248 1420 let _ = False 1421 + 1422 + let _ = True == False 1423 + let _ = False != True 1424 + 1425 + let _ = 1 > 2 1426 + let _ = 1 >= 2 1427 + let _ = 1 < 2 1428 + let _ = 1 <= 2 1429 + 1430 + let _ = 1.0 >. 2.0 1431 + let _ = 1.0 >=. 2.0 1432 + let _ = 1.0 <. 2.0 1433 + let _ = 1.0 <=. 2.0 1434 + }"# 1435 + )); 1436 + 1437 + insta::assert_debug_snapshot!(translate( 1438 + r#"pub fn guard_operations(n: Int, f: Float) -> Int { 1439 + case n, f { 1440 + x, y if x == 0 -> 1 1441 + x, y if x != 1 -> 2 1442 + x, y if x > 2 -> 3 1443 + x, y if x >= 3 -> 4 1444 + x, y if x < 4 -> 5 1445 + x, y if x <= 5 -> 6 1446 + x, y if y >. 1.0 -> 7 1447 + x, y if y >=. 2.0 -> 8 1448 + x, y if y <. 3.0 -> 9 1449 + x, y if y <=. 4.0 -> 10 1450 + x, y if x > 0 && x < 10 -> 11 1451 + x, y if x < 0 || x > 100 -> 12 1452 + x, y if !{ x == 0 } -> 13 1453 + x, y if x + 1 > 5 -> 14 1454 + x, y if x - 1 < 0 -> 15 1455 + x, y if x * 2 == 10 -> 16 1456 + x, y if x / 2 == 1 -> 17 1457 + x, y if y +. 1.0 >. 5.0 -> 18 1458 + x, y if y -. 1.0 <. 0.0 -> 19 1459 + x, y if y *. 2.0 == 4.0 -> 20 1460 + x, y if y /. 2.0 >=. 1.0 -> 21 1461 + _, _ -> 0 1462 + } 1249 1463 }"# 1250 1464 )) 1251 1465 }

+132 -2

compiler-core/src/cranelift/snapshots/gleam_core__cranelift__mir__tests__translates_samples-6.snap

View file

··· 1 1 --- 2 2 source: compiler-core/src/cranelift/mir.rs 3 - expression: "translate(r#\"pub fn booleans() {\n let _ = True\n let _ = False\n }\"#)" 3 + expression: "translate(r#\"pub fn booleans() {\n let _ = True\n let _ = False\n\n let _ = True == False\n let _ = False != True\n\n let _ = 1 > 2\n let _ = 1 >= 2\n let _ = 1 < 2\n let _ = 1 <= 2\n\n let _ = 1.0 >. 2.0\n let _ = 1.0 >=. 2.0\n let _ = 1.0 <. 2.0\n let _ = 1.0 <=. 2.0\n }\"#)" 4 4 --- 5 5 Module { 6 6 functions: [ ··· 26 26 value: false, 27 27 }, 28 28 }, 29 + Set { 30 + name: Var { 31 + name: "_tmp$3", 32 + }, 33 + value: Equals { 34 + lhs: Bool { 35 + value: true, 36 + }, 37 + rhs: Bool { 38 + value: false, 39 + }, 40 + }, 41 + }, 42 + Set { 43 + name: Var { 44 + name: "_tmp$4", 45 + }, 46 + value: NotEquals { 47 + lhs: Bool { 48 + value: false, 49 + }, 50 + rhs: Bool { 51 + value: true, 52 + }, 53 + }, 54 + }, 55 + Set { 56 + name: Var { 57 + name: "_tmp$5", 58 + }, 59 + value: IntGt { 60 + lhs: Int { 61 + value: 1, 62 + }, 63 + rhs: Int { 64 + value: 2, 65 + }, 66 + }, 67 + }, 68 + Set { 69 + name: Var { 70 + name: "_tmp$6", 71 + }, 72 + value: IntGtEq { 73 + lhs: Int { 74 + value: 1, 75 + }, 76 + rhs: Int { 77 + value: 2, 78 + }, 79 + }, 80 + }, 81 + Set { 82 + name: Var { 83 + name: "_tmp$7", 84 + }, 85 + value: IntLt { 86 + lhs: Int { 87 + value: 1, 88 + }, 89 + rhs: Int { 90 + value: 2, 91 + }, 92 + }, 93 + }, 94 + Set { 95 + name: Var { 96 + name: "_tmp$8", 97 + }, 98 + value: IntLtEq { 99 + lhs: Int { 100 + value: 1, 101 + }, 102 + rhs: Int { 103 + value: 2, 104 + }, 105 + }, 106 + }, 107 + Set { 108 + name: Var { 109 + name: "_tmp$9", 110 + }, 111 + value: FloatGt { 112 + lhs: Float { 113 + value: "1.0", 114 + }, 115 + rhs: Float { 116 + value: "2.0", 117 + }, 118 + }, 119 + }, 120 + Set { 121 + name: Var { 122 + name: "_tmp$10", 123 + }, 124 + value: FloatGtEq { 125 + lhs: Float { 126 + value: "1.0", 127 + }, 128 + rhs: Float { 129 + value: "2.0", 130 + }, 131 + }, 132 + }, 133 + Set { 134 + name: Var { 135 + name: "_tmp$11", 136 + }, 137 + value: FloatLt { 138 + lhs: Float { 139 + value: "1.0", 140 + }, 141 + rhs: Float { 142 + value: "2.0", 143 + }, 144 + }, 145 + }, 146 + Set { 147 + name: Var { 148 + name: "_tmp$12", 149 + }, 150 + value: FloatLtEq { 151 + lhs: Float { 152 + value: "1.0", 153 + }, 154 + rhs: Float { 155 + value: "2.0", 156 + }, 157 + }, 158 + }, 29 159 Var( 30 160 Var { 31 - name: "_tmp$2", 161 + name: "_tmp$12", 32 162 }, 33 163 ), 34 164 ],

+1027

compiler-core/src/cranelift/snapshots/gleam_core__cranelift__mir__tests__translates_samples-7.snap

View file

··· 1 + --- 2 + source: compiler-core/src/cranelift/mir.rs 3 + expression: "translate(r#\"pub fn guard_operations(n: Int, f: Float) -> Int {\n case n, f {\n x, y if x == 0 -> 1\n x, y if x != 1 -> 2\n x, y if x > 2 -> 3\n x, y if x >= 3 -> 4\n x, y if x < 4 -> 5\n x, y if x <= 5 -> 6\n x, y if y >. 1.0 -> 7\n x, y if y >=. 2.0 -> 8\n x, y if y <. 3.0 -> 9\n x, y if y <=. 4.0 -> 10\n x, y if x > 0 && x < 10 -> 11\n x, y if x < 0 || x > 100 -> 12\n x, y if !{ x == 0 } -> 13\n x, y if x + 1 > 5 -> 14\n x, y if x - 1 < 0 -> 15\n x, y if x * 2 == 10 -> 16\n x, y if x / 2 == 1 -> 17\n x, y if y +. 1.0 >. 5.0 -> 18\n x, y if y -. 1.0 <. 0.0 -> 19\n x, y if y *. 2.0 == 4.0 -> 20\n x, y if y /. 2.0 >=. 1.0 -> 21\n _, _ -> 0\n }\n }\"#)" 4 + --- 5 + Module { 6 + functions: [ 7 + Function { 8 + name: "guard_operations", 9 + return_type: Int, 10 + parameters: [ 11 + FunctionParameter { 12 + type_: Int, 13 + name: Some( 14 + "n", 15 + ), 16 + }, 17 + FunctionParameter { 18 + type_: Float, 19 + name: Some( 20 + "f", 21 + ), 22 + }, 23 + ], 24 + body: Block( 25 + [ 26 + Set { 27 + name: Var { 28 + name: "_tmp$3", 29 + }, 30 + value: Var( 31 + Var { 32 + name: "n$1", 33 + }, 34 + ), 35 + }, 36 + Set { 37 + name: Var { 38 + name: "_tmp$4", 39 + }, 40 + value: Var( 41 + Var { 42 + name: "f$2", 43 + }, 44 + ), 45 + }, 46 + Set { 47 + name: Var { 48 + name: "x$5", 49 + }, 50 + value: Var( 51 + Var { 52 + name: "_tmp$3", 53 + }, 54 + ), 55 + }, 56 + If { 57 + cond: Equals { 58 + lhs: Var( 59 + Var { 60 + name: "x$5", 61 + }, 62 + ), 63 + rhs: Int { 64 + value: 0, 65 + }, 66 + }, 67 + then: Block( 68 + [ 69 + Set { 70 + name: Var { 71 + name: "y$6", 72 + }, 73 + value: Var( 74 + Var { 75 + name: "_tmp$4", 76 + }, 77 + ), 78 + }, 79 + Int { 80 + value: 1, 81 + }, 82 + ], 83 + ), 84 + else_: Block( 85 + [ 86 + Set { 87 + name: Var { 88 + name: "x$7", 89 + }, 90 + value: Var( 91 + Var { 92 + name: "_tmp$3", 93 + }, 94 + ), 95 + }, 96 + If { 97 + cond: NotEquals { 98 + lhs: Var( 99 + Var { 100 + name: "x$7", 101 + }, 102 + ), 103 + rhs: Int { 104 + value: 1, 105 + }, 106 + }, 107 + then: Block( 108 + [ 109 + Set { 110 + name: Var { 111 + name: "y$8", 112 + }, 113 + value: Var( 114 + Var { 115 + name: "_tmp$4", 116 + }, 117 + ), 118 + }, 119 + Int { 120 + value: 2, 121 + }, 122 + ], 123 + ), 124 + else_: Block( 125 + [ 126 + Set { 127 + name: Var { 128 + name: "x$9", 129 + }, 130 + value: Var( 131 + Var { 132 + name: "_tmp$3", 133 + }, 134 + ), 135 + }, 136 + If { 137 + cond: IntGt { 138 + lhs: Var( 139 + Var { 140 + name: "x$9", 141 + }, 142 + ), 143 + rhs: Int { 144 + value: 2, 145 + }, 146 + }, 147 + then: Block( 148 + [ 149 + Set { 150 + name: Var { 151 + name: "y$10", 152 + }, 153 + value: Var( 154 + Var { 155 + name: "_tmp$4", 156 + }, 157 + ), 158 + }, 159 + Int { 160 + value: 3, 161 + }, 162 + ], 163 + ), 164 + else_: Block( 165 + [ 166 + Set { 167 + name: Var { 168 + name: "x$11", 169 + }, 170 + value: Var( 171 + Var { 172 + name: "_tmp$3", 173 + }, 174 + ), 175 + }, 176 + If { 177 + cond: IntGtEq { 178 + lhs: Var( 179 + Var { 180 + name: "x$11", 181 + }, 182 + ), 183 + rhs: Int { 184 + value: 3, 185 + }, 186 + }, 187 + then: Block( 188 + [ 189 + Set { 190 + name: Var { 191 + name: "y$12", 192 + }, 193 + value: Var( 194 + Var { 195 + name: "_tmp$4", 196 + }, 197 + ), 198 + }, 199 + Int { 200 + value: 4, 201 + }, 202 + ], 203 + ), 204 + else_: Block( 205 + [ 206 + Set { 207 + name: Var { 208 + name: "x$13", 209 + }, 210 + value: Var( 211 + Var { 212 + name: "_tmp$3", 213 + }, 214 + ), 215 + }, 216 + If { 217 + cond: IntLt { 218 + lhs: Var( 219 + Var { 220 + name: "x$13", 221 + }, 222 + ), 223 + rhs: Int { 224 + value: 4, 225 + }, 226 + }, 227 + then: Block( 228 + [ 229 + Set { 230 + name: Var { 231 + name: "y$14", 232 + }, 233 + value: Var( 234 + Var { 235 + name: "_tmp$4", 236 + }, 237 + ), 238 + }, 239 + Int { 240 + value: 5, 241 + }, 242 + ], 243 + ), 244 + else_: Block( 245 + [ 246 + Set { 247 + name: Var { 248 + name: "x$15", 249 + }, 250 + value: Var( 251 + Var { 252 + name: "_tmp$3", 253 + }, 254 + ), 255 + }, 256 + If { 257 + cond: IntLtEq { 258 + lhs: Var( 259 + Var { 260 + name: "x$15", 261 + }, 262 + ), 263 + rhs: Int { 264 + value: 5, 265 + }, 266 + }, 267 + then: Block( 268 + [ 269 + Set { 270 + name: Var { 271 + name: "y$16", 272 + }, 273 + value: Var( 274 + Var { 275 + name: "_tmp$4", 276 + }, 277 + ), 278 + }, 279 + Int { 280 + value: 6, 281 + }, 282 + ], 283 + ), 284 + else_: Block( 285 + [ 286 + Set { 287 + name: Var { 288 + name: "y$17", 289 + }, 290 + value: Var( 291 + Var { 292 + name: "_tmp$4", 293 + }, 294 + ), 295 + }, 296 + If { 297 + cond: FloatGt { 298 + lhs: Var( 299 + Var { 300 + name: "y$17", 301 + }, 302 + ), 303 + rhs: Float { 304 + value: "1.0", 305 + }, 306 + }, 307 + then: Block( 308 + [ 309 + Set { 310 + name: Var { 311 + name: "x$18", 312 + }, 313 + value: Var( 314 + Var { 315 + name: "_tmp$3", 316 + }, 317 + ), 318 + }, 319 + Int { 320 + value: 7, 321 + }, 322 + ], 323 + ), 324 + else_: Block( 325 + [ 326 + Set { 327 + name: Var { 328 + name: "y$19", 329 + }, 330 + value: Var( 331 + Var { 332 + name: "_tmp$4", 333 + }, 334 + ), 335 + }, 336 + If { 337 + cond: FloatGtEq { 338 + lhs: Var( 339 + Var { 340 + name: "y$19", 341 + }, 342 + ), 343 + rhs: Float { 344 + value: "2.0", 345 + }, 346 + }, 347 + then: Block( 348 + [ 349 + Set { 350 + name: Var { 351 + name: "x$20", 352 + }, 353 + value: Var( 354 + Var { 355 + name: "_tmp$3", 356 + }, 357 + ), 358 + }, 359 + Int { 360 + value: 8, 361 + }, 362 + ], 363 + ), 364 + else_: Block( 365 + [ 366 + Set { 367 + name: Var { 368 + name: "y$21", 369 + }, 370 + value: Var( 371 + Var { 372 + name: "_tmp$4", 373 + }, 374 + ), 375 + }, 376 + If { 377 + cond: FloatLt { 378 + lhs: Var( 379 + Var { 380 + name: "y$21", 381 + }, 382 + ), 383 + rhs: Float { 384 + value: "3.0", 385 + }, 386 + }, 387 + then: Block( 388 + [ 389 + Set { 390 + name: Var { 391 + name: "x$22", 392 + }, 393 + value: Var( 394 + Var { 395 + name: "_tmp$3", 396 + }, 397 + ), 398 + }, 399 + Int { 400 + value: 9, 401 + }, 402 + ], 403 + ), 404 + else_: Block( 405 + [ 406 + Set { 407 + name: Var { 408 + name: "y$23", 409 + }, 410 + value: Var( 411 + Var { 412 + name: "_tmp$4", 413 + }, 414 + ), 415 + }, 416 + If { 417 + cond: FloatLtEq { 418 + lhs: Var( 419 + Var { 420 + name: "y$23", 421 + }, 422 + ), 423 + rhs: Float { 424 + value: "4.0", 425 + }, 426 + }, 427 + then: Block( 428 + [ 429 + Set { 430 + name: Var { 431 + name: "x$24", 432 + }, 433 + value: Var( 434 + Var { 435 + name: "_tmp$3", 436 + }, 437 + ), 438 + }, 439 + Int { 440 + value: 10, 441 + }, 442 + ], 443 + ), 444 + else_: Block( 445 + [ 446 + Set { 447 + name: Var { 448 + name: "x$25", 449 + }, 450 + value: Var( 451 + Var { 452 + name: "_tmp$3", 453 + }, 454 + ), 455 + }, 456 + If { 457 + cond: If { 458 + cond: IntGt { 459 + lhs: Var( 460 + Var { 461 + name: "x$25", 462 + }, 463 + ), 464 + rhs: Int { 465 + value: 0, 466 + }, 467 + }, 468 + then: IntLt { 469 + lhs: Var( 470 + Var { 471 + name: "x$25", 472 + }, 473 + ), 474 + rhs: Int { 475 + value: 10, 476 + }, 477 + }, 478 + else_: Bool { 479 + value: false, 480 + }, 481 + }, 482 + then: Block( 483 + [ 484 + Set { 485 + name: Var { 486 + name: "y$26", 487 + }, 488 + value: Var( 489 + Var { 490 + name: "_tmp$4", 491 + }, 492 + ), 493 + }, 494 + Int { 495 + value: 11, 496 + }, 497 + ], 498 + ), 499 + else_: Block( 500 + [ 501 + Set { 502 + name: Var { 503 + name: "x$27", 504 + }, 505 + value: Var( 506 + Var { 507 + name: "_tmp$3", 508 + }, 509 + ), 510 + }, 511 + If { 512 + cond: If { 513 + cond: IntLt { 514 + lhs: Var( 515 + Var { 516 + name: "x$27", 517 + }, 518 + ), 519 + rhs: Int { 520 + value: 0, 521 + }, 522 + }, 523 + then: Bool { 524 + value: true, 525 + }, 526 + else_: IntGt { 527 + lhs: Var( 528 + Var { 529 + name: "x$27", 530 + }, 531 + ), 532 + rhs: Int { 533 + value: 100, 534 + }, 535 + }, 536 + }, 537 + then: Block( 538 + [ 539 + Set { 540 + name: Var { 541 + name: "y$28", 542 + }, 543 + value: Var( 544 + Var { 545 + name: "_tmp$4", 546 + }, 547 + ), 548 + }, 549 + Int { 550 + value: 12, 551 + }, 552 + ], 553 + ), 554 + else_: Block( 555 + [ 556 + Set { 557 + name: Var { 558 + name: "x$29", 559 + }, 560 + value: Var( 561 + Var { 562 + name: "_tmp$3", 563 + }, 564 + ), 565 + }, 566 + If { 567 + cond: Equals { 568 + lhs: Equals { 569 + lhs: Var( 570 + Var { 571 + name: "x$29", 572 + }, 573 + ), 574 + rhs: Int { 575 + value: 0, 576 + }, 577 + }, 578 + rhs: Bool { 579 + value: false, 580 + }, 581 + }, 582 + then: Block( 583 + [ 584 + Set { 585 + name: Var { 586 + name: "y$30", 587 + }, 588 + value: Var( 589 + Var { 590 + name: "_tmp$4", 591 + }, 592 + ), 593 + }, 594 + Int { 595 + value: 13, 596 + }, 597 + ], 598 + ), 599 + else_: Block( 600 + [ 601 + Set { 602 + name: Var { 603 + name: "x$31", 604 + }, 605 + value: Var( 606 + Var { 607 + name: "_tmp$3", 608 + }, 609 + ), 610 + }, 611 + If { 612 + cond: IntGt { 613 + lhs: IntAdd { 614 + lhs: Var( 615 + Var { 616 + name: "x$31", 617 + }, 618 + ), 619 + rhs: Int { 620 + value: 1, 621 + }, 622 + }, 623 + rhs: Int { 624 + value: 5, 625 + }, 626 + }, 627 + then: Block( 628 + [ 629 + Set { 630 + name: Var { 631 + name: "y$32", 632 + }, 633 + value: Var( 634 + Var { 635 + name: "_tmp$4", 636 + }, 637 + ), 638 + }, 639 + Int { 640 + value: 14, 641 + }, 642 + ], 643 + ), 644 + else_: Block( 645 + [ 646 + Set { 647 + name: Var { 648 + name: "x$33", 649 + }, 650 + value: Var( 651 + Var { 652 + name: "_tmp$3", 653 + }, 654 + ), 655 + }, 656 + If { 657 + cond: IntLt { 658 + lhs: IntSub { 659 + lhs: Var( 660 + Var { 661 + name: "x$33", 662 + }, 663 + ), 664 + rhs: Int { 665 + value: 1, 666 + }, 667 + }, 668 + rhs: Int { 669 + value: 0, 670 + }, 671 + }, 672 + then: Block( 673 + [ 674 + Set { 675 + name: Var { 676 + name: "y$34", 677 + }, 678 + value: Var( 679 + Var { 680 + name: "_tmp$4", 681 + }, 682 + ), 683 + }, 684 + Int { 685 + value: 15, 686 + }, 687 + ], 688 + ), 689 + else_: Block( 690 + [ 691 + Set { 692 + name: Var { 693 + name: "x$35", 694 + }, 695 + value: Var( 696 + Var { 697 + name: "_tmp$3", 698 + }, 699 + ), 700 + }, 701 + If { 702 + cond: Equals { 703 + lhs: IntMul { 704 + lhs: Var( 705 + Var { 706 + name: "x$35", 707 + }, 708 + ), 709 + rhs: Int { 710 + value: 2, 711 + }, 712 + }, 713 + rhs: Int { 714 + value: 10, 715 + }, 716 + }, 717 + then: Block( 718 + [ 719 + Set { 720 + name: Var { 721 + name: "y$36", 722 + }, 723 + value: Var( 724 + Var { 725 + name: "_tmp$4", 726 + }, 727 + ), 728 + }, 729 + Int { 730 + value: 16, 731 + }, 732 + ], 733 + ), 734 + else_: Block( 735 + [ 736 + Set { 737 + name: Var { 738 + name: "x$37", 739 + }, 740 + value: Var( 741 + Var { 742 + name: "_tmp$3", 743 + }, 744 + ), 745 + }, 746 + If { 747 + cond: Equals { 748 + lhs: IntDiv { 749 + lhs: Var( 750 + Var { 751 + name: "x$37", 752 + }, 753 + ), 754 + rhs: Int { 755 + value: 2, 756 + }, 757 + }, 758 + rhs: Int { 759 + value: 1, 760 + }, 761 + }, 762 + then: Block( 763 + [ 764 + Set { 765 + name: Var { 766 + name: "y$38", 767 + }, 768 + value: Var( 769 + Var { 770 + name: "_tmp$4", 771 + }, 772 + ), 773 + }, 774 + Int { 775 + value: 17, 776 + }, 777 + ], 778 + ), 779 + else_: Block( 780 + [ 781 + Set { 782 + name: Var { 783 + name: "y$39", 784 + }, 785 + value: Var( 786 + Var { 787 + name: "_tmp$4", 788 + }, 789 + ), 790 + }, 791 + If { 792 + cond: FloatGt { 793 + lhs: FloatAdd { 794 + lhs: Var( 795 + Var { 796 + name: "y$39", 797 + }, 798 + ), 799 + rhs: Float { 800 + value: "1.0", 801 + }, 802 + }, 803 + rhs: Float { 804 + value: "5.0", 805 + }, 806 + }, 807 + then: Block( 808 + [ 809 + Set { 810 + name: Var { 811 + name: "x$40", 812 + }, 813 + value: Var( 814 + Var { 815 + name: "_tmp$3", 816 + }, 817 + ), 818 + }, 819 + Int { 820 + value: 18, 821 + }, 822 + ], 823 + ), 824 + else_: Block( 825 + [ 826 + Set { 827 + name: Var { 828 + name: "y$41", 829 + }, 830 + value: Var( 831 + Var { 832 + name: "_tmp$4", 833 + }, 834 + ), 835 + }, 836 + If { 837 + cond: FloatLt { 838 + lhs: FloatSub { 839 + lhs: Var( 840 + Var { 841 + name: "y$41", 842 + }, 843 + ), 844 + rhs: Float { 845 + value: "1.0", 846 + }, 847 + }, 848 + rhs: Float { 849 + value: "0.0", 850 + }, 851 + }, 852 + then: Block( 853 + [ 854 + Set { 855 + name: Var { 856 + name: "x$42", 857 + }, 858 + value: Var( 859 + Var { 860 + name: "_tmp$3", 861 + }, 862 + ), 863 + }, 864 + Int { 865 + value: 19, 866 + }, 867 + ], 868 + ), 869 + else_: Block( 870 + [ 871 + Set { 872 + name: Var { 873 + name: "y$43", 874 + }, 875 + value: Var( 876 + Var { 877 + name: "_tmp$4", 878 + }, 879 + ), 880 + }, 881 + If { 882 + cond: Equals { 883 + lhs: FloatMul { 884 + lhs: Var( 885 + Var { 886 + name: "y$43", 887 + }, 888 + ), 889 + rhs: Float { 890 + value: "2.0", 891 + }, 892 + }, 893 + rhs: Float { 894 + value: "4.0", 895 + }, 896 + }, 897 + then: Block( 898 + [ 899 + Set { 900 + name: Var { 901 + name: "x$44", 902 + }, 903 + value: Var( 904 + Var { 905 + name: "_tmp$3", 906 + }, 907 + ), 908 + }, 909 + Int { 910 + value: 20, 911 + }, 912 + ], 913 + ), 914 + else_: Block( 915 + [ 916 + Set { 917 + name: Var { 918 + name: "y$45", 919 + }, 920 + value: Var( 921 + Var { 922 + name: "_tmp$4", 923 + }, 924 + ), 925 + }, 926 + If { 927 + cond: FloatGtEq { 928 + lhs: FloatDiv { 929 + lhs: Var( 930 + Var { 931 + name: "y$45", 932 + }, 933 + ), 934 + rhs: Float { 935 + value: "2.0", 936 + }, 937 + }, 938 + rhs: Float { 939 + value: "1.0", 940 + }, 941 + }, 942 + then: Block( 943 + [ 944 + Set { 945 + name: Var { 946 + name: "x$46", 947 + }, 948 + value: Var( 949 + Var { 950 + name: "_tmp$3", 951 + }, 952 + ), 953 + }, 954 + Int { 955 + value: 21, 956 + }, 957 + ], 958 + ), 959 + else_: Int { 960 + value: 0, 961 + }, 962 + }, 963 + ], 964 + ), 965 + }, 966 + ], 967 + ), 968 + }, 969 + ], 970 + ), 971 + }, 972 + ], 973 + ), 974 + }, 975 + ], 976 + ), 977 + }, 978 + ], 979 + ), 980 + }, 981 + ], 982 + ), 983 + }, 984 + ], 985 + ), 986 + }, 987 + ], 988 + ), 989 + }, 990 + ], 991 + ), 992 + }, 993 + ], 994 + ), 995 + }, 996 + ], 997 + ), 998 + }, 999 + ], 1000 + ), 1001 + }, 1002 + ], 1003 + ), 1004 + }, 1005 + ], 1006 + ), 1007 + }, 1008 + ], 1009 + ), 1010 + }, 1011 + ], 1012 + ), 1013 + }, 1014 + ], 1015 + ), 1016 + }, 1017 + ], 1018 + ), 1019 + }, 1020 + ], 1021 + ), 1022 + }, 1023 + ], 1024 + ), 1025 + }, 1026 + ], 1027 + }

Configure Feed

Configure Feed