Created
October 20, 2017 08:01
-
-
Save nicolasstucki/36b8e437d0feae9501076b546c3e8643 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ``` | |
| def test(x: Object): Unit = | |
| { | |
| case val x117: Object = x | |
| def case378(): Unit = throw new MatchError(x117) | |
| def case379(): Unit = | |
| if x117.isInstanceOf[Foo29] then | |
| { | |
| case val x118: Foo29 = x117.asInstanceOf[Foo29] | |
| case val x119: Foo29 = Foo29.unapply(x118) | |
| case val x120: Int = x119._1() | |
| if 1.==(x120) then | |
| { | |
| case val x121: Int = x119._2() | |
| if 2.==(x121) then | |
| { | |
| case val x122: Int = x119._3() | |
| if 3.==(x122) then | |
| { | |
| case val x123: Int = x119._4() | |
| if 4.==(x123) then | |
| { | |
| case val x124: Int = x119._5() | |
| if 5.==(x124) then | |
| { | |
| case val x125: Int = x119._6() | |
| if 6.==(x125) then | |
| { | |
| case val x126: Int = x119._7() | |
| if 7.==(x126) then | |
| { | |
| case val x127: Int = x119._8() | |
| if 8.==(x127) then | |
| { | |
| case val x128: Int = x119._9() | |
| if 9.==(x128) then | |
| { | |
| case val x129: Int = x119._10() | |
| if 10.==(x129) then | |
| { | |
| Test.stuff() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| } | |
| else case378() | |
| def case380(): Unit = | |
| if x117.isInstanceOf[Foo28] then | |
| { | |
| case val x130: Foo28 = x117.asInstanceOf[Foo28] | |
| case val x131: Foo28 = Foo28.unapply(x130) | |
| case val x132: Int = x131._1() | |
| if 1.==(x132) then | |
| { | |
| case val x133: Int = x131._2() | |
| if 2.==(x133) then | |
| { | |
| case val x134: Int = x131._3() | |
| if 3.==(x134) then | |
| { | |
| case val x135: Int = x131._4() | |
| if 4.==(x135) then | |
| { | |
| case val x136: Int = x131._5() | |
| if 5.==(x136) then | |
| { | |
| case val x137: Int = x131._6() | |
| if 6.==(x137) then | |
| { | |
| case val x138: Int = x131._7() | |
| if 7.==(x138) then | |
| { | |
| case val x139: Int = x131._8() | |
| if 8.==(x139) then | |
| { | |
| case val x140: Int = x131._9() | |
| if 9.==(x140) then | |
| { | |
| case val x141: Int = x131._10() | |
| if 10.==(x141) then | |
| { | |
| Test.stuff() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| } | |
| else case379() | |
| def case381(): Unit = | |
| if x117.isInstanceOf[Foo27] then | |
| { | |
| case val x142: Foo27 = x117.asInstanceOf[Foo27] | |
| case val x143: Foo27 = Foo27.unapply(x142) | |
| case val x144: Int = x143._1() | |
| if 1.==(x144) then | |
| { | |
| case val x145: Int = x143._2() | |
| if 2.==(x145) then | |
| { | |
| case val x146: Int = x143._3() | |
| if 3.==(x146) then | |
| { | |
| case val x147: Int = x143._4() | |
| if 4.==(x147) then | |
| { | |
| case val x148: Int = x143._5() | |
| if 5.==(x148) then | |
| { | |
| case val x149: Int = x143._6() | |
| if 6.==(x149) then | |
| { | |
| case val x150: Int = x143._7() | |
| if 7.==(x150) then | |
| { | |
| case val x151: Int = x143._8() | |
| if 8.==(x151) then | |
| { | |
| case val x152: Int = x143._9() | |
| if 9.==(x152) then | |
| { | |
| case val x153: Int = x143._10() | |
| if 10.==(x153) then | |
| { | |
| Test.stuff() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| } | |
| else case380() | |
| def case382(): Unit = | |
| if x117.isInstanceOf[Foo26] then | |
| { | |
| case val x154: Foo26 = x117.asInstanceOf[Foo26] | |
| case val x155: Foo26 = Foo26.unapply(x154) | |
| case val x156: Int = x155._1() | |
| if 1.==(x156) then | |
| { | |
| case val x157: Int = x155._2() | |
| if 2.==(x157) then | |
| { | |
| case val x158: Int = x155._3() | |
| if 3.==(x158) then | |
| { | |
| case val x159: Int = x155._4() | |
| if 4.==(x159) then | |
| { | |
| case val x160: Int = x155._5() | |
| if 5.==(x160) then | |
| { | |
| case val x161: Int = x155._6() | |
| if 6.==(x161) then | |
| { | |
| case val x162: Int = x155._7() | |
| if 7.==(x162) then | |
| { | |
| case val x163: Int = x155._8() | |
| if 8.==(x163) then | |
| { | |
| case val x164: Int = x155._9() | |
| if 9.==(x164) then | |
| { | |
| case val x165: Int = x155._10() | |
| if 10.==(x165) then | |
| { | |
| Test.stuff() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| } | |
| else case381() | |
| def case383(): Unit = | |
| if x117.isInstanceOf[Foo25] then | |
| { | |
| case val x166: Foo25 = x117.asInstanceOf[Foo25] | |
| case val x167: Foo25 = Foo25.unapply(x166) | |
| case val x168: Int = x167._1() | |
| if 1.==(x168) then | |
| { | |
| case val x169: Int = x167._2() | |
| if 2.==(x169) then | |
| { | |
| case val x170: Int = x167._3() | |
| if 3.==(x170) then | |
| { | |
| case val x171: Int = x167._4() | |
| if 4.==(x171) then | |
| { | |
| case val x172: Int = x167._5() | |
| if 5.==(x172) then | |
| { | |
| case val x173: Int = x167._6() | |
| if 6.==(x173) then | |
| { | |
| case val x174: Int = x167._7() | |
| if 7.==(x174) then | |
| { | |
| case val x175: Int = x167._8() | |
| if 8.==(x175) then | |
| { | |
| case val x176: Int = x167._9() | |
| if 9.==(x176) then | |
| { | |
| case val x177: Int = x167._10() | |
| if 10.==(x177) then | |
| { | |
| Test.stuff() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| } | |
| else case382() | |
| def case384(): Unit = | |
| if x117.isInstanceOf[Foo24] then | |
| { | |
| case val x178: Foo24 = x117.asInstanceOf[Foo24] | |
| case val x179: Foo24 = Foo24.unapply(x178) | |
| case val x180: Int = x179._1() | |
| if 1.==(x180) then | |
| { | |
| case val x181: Int = x179._2() | |
| if 2.==(x181) then | |
| { | |
| case val x182: Int = x179._3() | |
| if 3.==(x182) then | |
| { | |
| case val x183: Int = x179._4() | |
| if 4.==(x183) then | |
| { | |
| case val x184: Int = x179._5() | |
| if 5.==(x184) then | |
| { | |
| case val x185: Int = x179._6() | |
| if 6.==(x185) then | |
| { | |
| case val x186: Int = x179._7() | |
| if 7.==(x186) then | |
| { | |
| case val x187: Int = x179._8() | |
| if 8.==(x187) then | |
| { | |
| case val x188: Int = x179._9() | |
| if 9.==(x188) then | |
| { | |
| case val x189: Int = x179._10() | |
| if 10.==(x189) then | |
| { | |
| Test.stuff() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| } | |
| else case383() | |
| def case385(): Unit = | |
| if x117.isInstanceOf[Foo23] then | |
| { | |
| case val x190: Foo23 = x117.asInstanceOf[Foo23] | |
| case val x191: Foo23 = Foo23.unapply(x190) | |
| case val x192: Int = x191._1() | |
| if 1.==(x192) then | |
| { | |
| case val x193: Int = x191._2() | |
| if 2.==(x193) then | |
| { | |
| case val x194: Int = x191._3() | |
| if 3.==(x194) then | |
| { | |
| case val x195: Int = x191._4() | |
| if 4.==(x195) then | |
| { | |
| case val x196: Int = x191._5() | |
| if 5.==(x196) then | |
| { | |
| case val x197: Int = x191._6() | |
| if 6.==(x197) then | |
| { | |
| case val x198: Int = x191._7() | |
| if 7.==(x198) then | |
| { | |
| case val x199: Int = x191._8() | |
| if 8.==(x199) then | |
| { | |
| case val x200: Int = x191._9() | |
| if 9.==(x200) then | |
| { | |
| case val x201: Int = x191._10() | |
| if 10.==(x201) then | |
| { | |
| Test.stuff() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| } | |
| else case384() | |
| def case386(): Unit = | |
| if x117.isInstanceOf[Foo22] then | |
| { | |
| case val x202: Foo22 = x117.asInstanceOf[Foo22] | |
| case val x203: Foo22 = Foo22.unapply(x202) | |
| case val x204: Int = x203._1() | |
| if 1.==(x204) then | |
| { | |
| case val x205: Int = x203._2() | |
| if 2.==(x205) then | |
| { | |
| case val x206: Int = x203._3() | |
| if 3.==(x206) then | |
| { | |
| case val x207: Int = x203._4() | |
| if 4.==(x207) then | |
| { | |
| case val x208: Int = x203._5() | |
| if 5.==(x208) then | |
| { | |
| case val x209: Int = x203._6() | |
| if 6.==(x209) then | |
| { | |
| case val x210: Int = x203._7() | |
| if 7.==(x210) then | |
| { | |
| case val x211: Int = x203._8() | |
| if 8.==(x211) then | |
| { | |
| case val x212: Int = x203._9() | |
| if 9.==(x212) then | |
| { | |
| case val x213: Int = x203._10() | |
| if 10.==(x213) then | |
| { | |
| Test.stuff() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| } | |
| else case385() | |
| def case387(): Unit = | |
| if x117.isInstanceOf[Foo21] then | |
| { | |
| case val x214: Foo21 = x117.asInstanceOf[Foo21] | |
| case val x215: Foo21 = Foo21.unapply(x214) | |
| case val x216: Int = x215._1() | |
| if 1.==(x216) then | |
| { | |
| case val x217: Int = x215._2() | |
| if 2.==(x217) then | |
| { | |
| case val x218: Int = x215._3() | |
| if 3.==(x218) then | |
| { | |
| case val x219: Int = x215._4() | |
| if 4.==(x219) then | |
| { | |
| case val x220: Int = x215._5() | |
| if 5.==(x220) then | |
| { | |
| case val x221: Int = x215._6() | |
| if 6.==(x221) then | |
| { | |
| case val x222: Int = x215._7() | |
| if 7.==(x222) then | |
| { | |
| case val x223: Int = x215._8() | |
| if 8.==(x223) then | |
| { | |
| case val x224: Int = x215._9() | |
| if 9.==(x224) then | |
| { | |
| case val x225: Int = x215._10() | |
| if 10.==(x225) then | |
| { | |
| Test.stuff() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| } | |
| else case386() | |
| def case388(): Unit = | |
| if x117.isInstanceOf[Foo20] then | |
| { | |
| case val x226: Foo20 = x117.asInstanceOf[Foo20] | |
| case val x227: Foo20 = Foo20.unapply(x226) | |
| case val x228: Int = x227._1() | |
| if 1.==(x228) then | |
| { | |
| case val x229: Int = x227._2() | |
| if 2.==(x229) then | |
| { | |
| case val x230: Int = x227._3() | |
| if 3.==(x230) then | |
| { | |
| case val x231: Int = x227._4() | |
| if 4.==(x231) then | |
| { | |
| case val x232: Int = x227._5() | |
| if 5.==(x232) then | |
| { | |
| case val x233: Int = x227._6() | |
| if 6.==(x233) then | |
| { | |
| case val x234: Int = x227._7() | |
| if 7.==(x234) then | |
| { | |
| case val x235: Int = x227._8() | |
| if 8.==(x235) then | |
| { | |
| case val x236: Int = x227._9() | |
| if 9.==(x236) then | |
| { | |
| case val x237: Int = x227._10() | |
| if 10.==(x237) then | |
| { | |
| Test.stuff() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| } | |
| else case387() | |
| def case389(): Unit = | |
| if x117.isInstanceOf[Foo19] then | |
| { | |
| case val x238: Foo19 = x117.asInstanceOf[Foo19] | |
| case val x239: Foo19 = Foo19.unapply(x238) | |
| case val x240: Int = x239._1() | |
| if 1.==(x240) then | |
| { | |
| case val x241: Int = x239._2() | |
| if 2.==(x241) then | |
| { | |
| case val x242: Int = x239._3() | |
| if 3.==(x242) then | |
| { | |
| case val x243: Int = x239._4() | |
| if 4.==(x243) then | |
| { | |
| case val x244: Int = x239._5() | |
| if 5.==(x244) then | |
| { | |
| case val x245: Int = x239._6() | |
| if 6.==(x245) then | |
| { | |
| case val x246: Int = x239._7() | |
| if 7.==(x246) then | |
| { | |
| case val x247: Int = x239._8() | |
| if 8.==(x247) then | |
| { | |
| case val x248: Int = x239._9() | |
| if 9.==(x248) then | |
| { | |
| case val x249: Int = x239._10() | |
| if 10.==(x249) then | |
| { | |
| Test.stuff() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| } | |
| else case388() | |
| def case390(): Unit = | |
| if x117.isInstanceOf[Foo18] then | |
| { | |
| case val x250: Foo18 = x117.asInstanceOf[Foo18] | |
| case val x251: Foo18 = Foo18.unapply(x250) | |
| case val x252: Int = x251._1() | |
| if 1.==(x252) then | |
| { | |
| case val x253: Int = x251._2() | |
| if 2.==(x253) then | |
| { | |
| case val x254: Int = x251._3() | |
| if 3.==(x254) then | |
| { | |
| case val x255: Int = x251._4() | |
| if 4.==(x255) then | |
| { | |
| case val x256: Int = x251._5() | |
| if 5.==(x256) then | |
| { | |
| case val x257: Int = x251._6() | |
| if 6.==(x257) then | |
| { | |
| case val x258: Int = x251._7() | |
| if 7.==(x258) then | |
| { | |
| case val x259: Int = x251._8() | |
| if 8.==(x259) then | |
| { | |
| case val x260: Int = x251._9() | |
| if 9.==(x260) then | |
| { | |
| case val x261: Int = x251._10() | |
| if 10.==(x261) then | |
| { | |
| Test.stuff() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| } | |
| else case389() | |
| def case391(): Unit = | |
| if x117.isInstanceOf[Foo17] then | |
| { | |
| case val x262: Foo17 = x117.asInstanceOf[Foo17] | |
| case val x263: Foo17 = Foo17.unapply(x262) | |
| case val x264: Int = x263._1() | |
| if 1.==(x264) then | |
| { | |
| case val x265: Int = x263._2() | |
| if 2.==(x265) then | |
| { | |
| case val x266: Int = x263._3() | |
| if 3.==(x266) then | |
| { | |
| case val x267: Int = x263._4() | |
| if 4.==(x267) then | |
| { | |
| case val x268: Int = x263._5() | |
| if 5.==(x268) then | |
| { | |
| case val x269: Int = x263._6() | |
| if 6.==(x269) then | |
| { | |
| case val x270: Int = x263._7() | |
| if 7.==(x270) then | |
| { | |
| case val x271: Int = x263._8() | |
| if 8.==(x271) then | |
| { | |
| case val x272: Int = x263._9() | |
| if 9.==(x272) then | |
| { | |
| case val x273: Int = x263._10() | |
| if 10.==(x273) then | |
| { | |
| Test.stuff() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| } | |
| else case390() | |
| def case392(): Unit = | |
| if x117.isInstanceOf[Foo16] then | |
| { | |
| case val x274: Foo16 = x117.asInstanceOf[Foo16] | |
| case val x275: Foo16 = Foo16.unapply(x274) | |
| case val x276: Int = x275._1() | |
| if 1.==(x276) then | |
| { | |
| case val x277: Int = x275._2() | |
| if 2.==(x277) then | |
| { | |
| case val x278: Int = x275._3() | |
| if 3.==(x278) then | |
| { | |
| case val x279: Int = x275._4() | |
| if 4.==(x279) then | |
| { | |
| case val x280: Int = x275._5() | |
| if 5.==(x280) then | |
| { | |
| case val x281: Int = x275._6() | |
| if 6.==(x281) then | |
| { | |
| case val x282: Int = x275._7() | |
| if 7.==(x282) then | |
| { | |
| case val x283: Int = x275._8() | |
| if 8.==(x283) then | |
| { | |
| case val x284: Int = x275._9() | |
| if 9.==(x284) then | |
| { | |
| case val x285: Int = x275._10() | |
| if 10.==(x285) then | |
| { | |
| Test.stuff() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| } | |
| else case391() | |
| def case393(): Unit = | |
| if x117.isInstanceOf[Foo15] then | |
| { | |
| case val x286: Foo15 = x117.asInstanceOf[Foo15] | |
| case val x287: Foo15 = Foo15.unapply(x286) | |
| case val x288: Int = x287._1() | |
| if 1.==(x288) then | |
| { | |
| case val x289: Int = x287._2() | |
| if 2.==(x289) then | |
| { | |
| case val x290: Int = x287._3() | |
| if 3.==(x290) then | |
| { | |
| case val x291: Int = x287._4() | |
| if 4.==(x291) then | |
| { | |
| case val x292: Int = x287._5() | |
| if 5.==(x292) then | |
| { | |
| case val x293: Int = x287._6() | |
| if 6.==(x293) then | |
| { | |
| case val x294: Int = x287._7() | |
| if 7.==(x294) then | |
| { | |
| case val x295: Int = x287._8() | |
| if 8.==(x295) then | |
| { | |
| case val x296: Int = x287._9() | |
| if 9.==(x296) then | |
| { | |
| case val x297: Int = x287._10() | |
| if 10.==(x297) then | |
| { | |
| Test.stuff() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| } | |
| else case392() | |
| def case394(): Unit = | |
| if x117.isInstanceOf[Foo14] then | |
| { | |
| case val x298: Foo14 = x117.asInstanceOf[Foo14] | |
| case val x299: Foo14 = Foo14.unapply(x298) | |
| case val x300: Int = x299._1() | |
| if 1.==(x300) then | |
| { | |
| case val x301: Int = x299._2() | |
| if 2.==(x301) then | |
| { | |
| case val x302: Int = x299._3() | |
| if 3.==(x302) then | |
| { | |
| case val x303: Int = x299._4() | |
| if 4.==(x303) then | |
| { | |
| case val x304: Int = x299._5() | |
| if 5.==(x304) then | |
| { | |
| case val x305: Int = x299._6() | |
| if 6.==(x305) then | |
| { | |
| case val x306: Int = x299._7() | |
| if 7.==(x306) then | |
| { | |
| case val x307: Int = x299._8() | |
| if 8.==(x307) then | |
| { | |
| case val x308: Int = x299._9() | |
| if 9.==(x308) then | |
| { | |
| case val x309: Int = x299._10() | |
| if 10.==(x309) then | |
| { | |
| Test.stuff() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| } | |
| else case393() | |
| def case395(): Unit = | |
| if x117.isInstanceOf[Foo13] then | |
| { | |
| case val x310: Foo13 = x117.asInstanceOf[Foo13] | |
| case val x311: Foo13 = Foo13.unapply(x310) | |
| case val x312: Int = x311._1() | |
| if 1.==(x312) then | |
| { | |
| case val x313: Int = x311._2() | |
| if 2.==(x313) then | |
| { | |
| case val x314: Int = x311._3() | |
| if 3.==(x314) then | |
| { | |
| case val x315: Int = x311._4() | |
| if 4.==(x315) then | |
| { | |
| case val x316: Int = x311._5() | |
| if 5.==(x316) then | |
| { | |
| case val x317: Int = x311._6() | |
| if 6.==(x317) then | |
| { | |
| case val x318: Int = x311._7() | |
| if 7.==(x318) then | |
| { | |
| case val x319: Int = x311._8() | |
| if 8.==(x319) then | |
| { | |
| case val x320: Int = x311._9() | |
| if 9.==(x320) then | |
| { | |
| case val x321: Int = x311._10() | |
| if 10.==(x321) then | |
| { | |
| Test.stuff() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| } | |
| else case394() | |
| def case396(): Unit = | |
| if x117.isInstanceOf[Foo12] then | |
| { | |
| case val x322: Foo12 = x117.asInstanceOf[Foo12] | |
| case val x323: Foo12 = Foo12.unapply(x322) | |
| case val x324: Int = x323._1() | |
| if 1.==(x324) then | |
| { | |
| case val x325: Int = x323._2() | |
| if 2.==(x325) then | |
| { | |
| case val x326: Int = x323._3() | |
| if 3.==(x326) then | |
| { | |
| case val x327: Int = x323._4() | |
| if 4.==(x327) then | |
| { | |
| case val x328: Int = x323._5() | |
| if 5.==(x328) then | |
| { | |
| case val x329: Int = x323._6() | |
| if 6.==(x329) then | |
| { | |
| case val x330: Int = x323._7() | |
| if 7.==(x330) then | |
| { | |
| case val x331: Int = x323._8() | |
| if 8.==(x331) then | |
| { | |
| case val x332: Int = x323._9() | |
| if 9.==(x332) then | |
| { | |
| case val x333: Int = x323._10() | |
| if 10.==(x333) then | |
| { | |
| Test.stuff() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| } | |
| else case395() | |
| def case397(): Unit = | |
| if x117.isInstanceOf[Foo11] then | |
| { | |
| case val x334: Foo11 = x117.asInstanceOf[Foo11] | |
| case val x335: Foo11 = Foo11.unapply(x334) | |
| case val x336: Int = x335._1() | |
| if 1.==(x336) then | |
| { | |
| case val x337: Int = x335._2() | |
| if 2.==(x337) then | |
| { | |
| case val x338: Int = x335._3() | |
| if 3.==(x338) then | |
| { | |
| case val x339: Int = x335._4() | |
| if 4.==(x339) then | |
| { | |
| case val x340: Int = x335._5() | |
| if 5.==(x340) then | |
| { | |
| case val x341: Int = x335._6() | |
| if 6.==(x341) then | |
| { | |
| case val x342: Int = x335._7() | |
| if 7.==(x342) then | |
| { | |
| case val x343: Int = x335._8() | |
| if 8.==(x343) then | |
| { | |
| case val x344: Int = x335._9() | |
| if 9.==(x344) then | |
| { | |
| case val x345: Int = x335._10() | |
| if 10.==(x345) then | |
| { | |
| Test.stuff() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| } | |
| else case396() | |
| def case398(): Unit = | |
| if x117.isInstanceOf[Foo10] then | |
| { | |
| case val x346: Foo10 = x117.asInstanceOf[Foo10] | |
| case val x347: Foo10 = Foo10.unapply(x346) | |
| case val x348: Int = x347._1() | |
| if 1.==(x348) then | |
| { | |
| case val x349: Int = x347._2() | |
| if 2.==(x349) then | |
| { | |
| case val x350: Int = x347._3() | |
| if 3.==(x350) then | |
| { | |
| case val x351: Int = x347._4() | |
| if 4.==(x351) then | |
| { | |
| case val x352: Int = x347._5() | |
| if 5.==(x352) then | |
| { | |
| case val x353: Int = x347._6() | |
| if 6.==(x353) then | |
| { | |
| case val x354: Int = x347._7() | |
| if 7.==(x354) then | |
| { | |
| case val x355: Int = x347._8() | |
| if 8.==(x355) then | |
| { | |
| case val x356: Int = x347._9() | |
| if 9.==(x356) then | |
| { | |
| case val x357: Int = x347._10() | |
| if 10.==(x357) then | |
| { | |
| Test.stuff() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| } | |
| else case397() | |
| def case399(): Unit = | |
| if x117.isInstanceOf[Foo09] then | |
| { | |
| case val x358: Foo09 = x117.asInstanceOf[Foo09] | |
| case val x359: Foo09 = Foo09.unapply(x358) | |
| case val x360: Int = x359._1() | |
| if 1.==(x360) then | |
| { | |
| case val x361: Int = x359._2() | |
| if 2.==(x361) then | |
| { | |
| case val x362: Int = x359._3() | |
| if 3.==(x362) then | |
| { | |
| case val x363: Int = x359._4() | |
| if 4.==(x363) then | |
| { | |
| case val x364: Int = x359._5() | |
| if 5.==(x364) then | |
| { | |
| case val x365: Int = x359._6() | |
| if 6.==(x365) then | |
| { | |
| case val x366: Int = x359._7() | |
| if 7.==(x366) then | |
| { | |
| case val x367: Int = x359._8() | |
| if 8.==(x367) then | |
| { | |
| case val x368: Int = x359._9() | |
| if 9.==(x368) then | |
| { | |
| case val x369: Int = x359._10() | |
| if 10.==(x369) then | |
| { | |
| Test.stuff() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| } | |
| else case398() | |
| def case400(): Unit = | |
| if x117.isInstanceOf[Foo08] then | |
| { | |
| case val x370: Foo08 = x117.asInstanceOf[Foo08] | |
| case val x371: Foo08 = Foo08.unapply(x370) | |
| case val x372: Int = x371._1() | |
| if 1.==(x372) then | |
| { | |
| case val x373: Int = x371._2() | |
| if 2.==(x373) then | |
| { | |
| case val x374: Int = x371._3() | |
| if 3.==(x374) then | |
| { | |
| case val x375: Int = x371._4() | |
| if 4.==(x375) then | |
| { | |
| case val x376: Int = x371._5() | |
| if 5.==(x376) then | |
| { | |
| case val x377: Int = x371._6() | |
| if 6.==(x377) then | |
| { | |
| case val x378: Int = x371._7() | |
| if 7.==(x378) then | |
| { | |
| case val x379: Int = x371._8() | |
| if 8.==(x379) then | |
| { | |
| case val x380: Int = x371._9() | |
| if 9.==(x380) then | |
| { | |
| case val x381: Int = x371._10() | |
| if 10.==(x381) then | |
| { | |
| Test.stuff() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| } | |
| else case399() | |
| def case401(): Unit = | |
| if x117.isInstanceOf[Foo07] then | |
| { | |
| case val x382: Foo07 = x117.asInstanceOf[Foo07] | |
| case val x383: Foo07 = Foo07.unapply(x382) | |
| case val x384: Int = x383._1() | |
| if 1.==(x384) then | |
| { | |
| case val x385: Int = x383._2() | |
| if 2.==(x385) then | |
| { | |
| case val x386: Int = x383._3() | |
| if 3.==(x386) then | |
| { | |
| case val x387: Int = x383._4() | |
| if 4.==(x387) then | |
| { | |
| case val x388: Int = x383._5() | |
| if 5.==(x388) then | |
| { | |
| case val x389: Int = x383._6() | |
| if 6.==(x389) then | |
| { | |
| case val x390: Int = x383._7() | |
| if 7.==(x390) then | |
| { | |
| case val x391: Int = x383._8() | |
| if 8.==(x391) then | |
| { | |
| case val x392: Int = x383._9() | |
| if 9.==(x392) then | |
| { | |
| case val x393: Int = x383._10() | |
| if 10.==(x393) then | |
| { | |
| Test.stuff() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| } | |
| else case400() | |
| def case402(): Unit = | |
| if x117.isInstanceOf[Foo06] then | |
| { | |
| case val x394: Foo06 = x117.asInstanceOf[Foo06] | |
| case val x395: Foo06 = Foo06.unapply(x394) | |
| case val x396: Int = x395._1() | |
| if 1.==(x396) then | |
| { | |
| case val x397: Int = x395._2() | |
| if 2.==(x397) then | |
| { | |
| case val x398: Int = x395._3() | |
| if 3.==(x398) then | |
| { | |
| case val x399: Int = x395._4() | |
| if 4.==(x399) then | |
| { | |
| case val x400: Int = x395._5() | |
| if 5.==(x400) then | |
| { | |
| case val x401: Int = x395._6() | |
| if 6.==(x401) then | |
| { | |
| case val x402: Int = x395._7() | |
| if 7.==(x402) then | |
| { | |
| case val x403: Int = x395._8() | |
| if 8.==(x403) then | |
| { | |
| case val x404: Int = x395._9() | |
| if 9.==(x404) then | |
| { | |
| case val x405: Int = x395._10() | |
| if 10.==(x405) then | |
| { | |
| Test.stuff() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| } | |
| else case401() | |
| def case403(): Unit = | |
| if x117.isInstanceOf[Foo05] then | |
| { | |
| case val x406: Foo05 = x117.asInstanceOf[Foo05] | |
| case val x407: Foo05 = Foo05.unapply(x406) | |
| case val x408: Int = x407._1() | |
| if 1.==(x408) then | |
| { | |
| case val x409: Int = x407._2() | |
| if 2.==(x409) then | |
| { | |
| case val x410: Int = x407._3() | |
| if 3.==(x410) then | |
| { | |
| case val x411: Int = x407._4() | |
| if 4.==(x411) then | |
| { | |
| case val x412: Int = x407._5() | |
| if 5.==(x412) then | |
| { | |
| case val x413: Int = x407._6() | |
| if 6.==(x413) then | |
| { | |
| case val x414: Int = x407._7() | |
| if 7.==(x414) then | |
| { | |
| case val x415: Int = x407._8() | |
| if 8.==(x415) then | |
| { | |
| case val x416: Int = x407._9() | |
| if 9.==(x416) then | |
| { | |
| case val x417: Int = x407._10() | |
| if 10.==(x417) then | |
| { | |
| Test.stuff() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| } | |
| else case402() | |
| def case404(): Unit = | |
| if x117.isInstanceOf[Foo04] then | |
| { | |
| case val x418: Foo04 = x117.asInstanceOf[Foo04] | |
| case val x419: Foo04 = Foo04.unapply(x418) | |
| case val x420: Int = x419._1() | |
| if 1.==(x420) then | |
| { | |
| case val x421: Int = x419._2() | |
| if 2.==(x421) then | |
| { | |
| case val x422: Int = x419._3() | |
| if 3.==(x422) then | |
| { | |
| case val x423: Int = x419._4() | |
| if 4.==(x423) then | |
| { | |
| case val x424: Int = x419._5() | |
| if 5.==(x424) then | |
| { | |
| case val x425: Int = x419._6() | |
| if 6.==(x425) then | |
| { | |
| case val x426: Int = x419._7() | |
| if 7.==(x426) then | |
| { | |
| case val x427: Int = x419._8() | |
| if 8.==(x427) then | |
| { | |
| case val x428: Int = x419._9() | |
| if 9.==(x428) then | |
| { | |
| case val x429: Int = x419._10() | |
| if 10.==(x429) then | |
| { | |
| Test.stuff() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| } | |
| else case403() | |
| def case405(): Unit = | |
| if x117.isInstanceOf[Foo03] then | |
| { | |
| case val x430: Foo03 = x117.asInstanceOf[Foo03] | |
| case val x431: Foo03 = Foo03.unapply(x430) | |
| case val x432: Int = x431._1() | |
| if 1.==(x432) then | |
| { | |
| case val x433: Int = x431._2() | |
| if 2.==(x433) then | |
| { | |
| case val x434: Int = x431._3() | |
| if 3.==(x434) then | |
| { | |
| case val x435: Int = x431._4() | |
| if 4.==(x435) then | |
| { | |
| case val x436: Int = x431._5() | |
| if 5.==(x436) then | |
| { | |
| case val x437: Int = x431._6() | |
| if 6.==(x437) then | |
| { | |
| case val x438: Int = x431._7() | |
| if 7.==(x438) then | |
| { | |
| case val x439: Int = x431._8() | |
| if 8.==(x439) then | |
| { | |
| case val x440: Int = x431._9() | |
| if 9.==(x440) then | |
| { | |
| case val x441: Int = x431._10() | |
| if 10.==(x441) then | |
| { | |
| Test.stuff() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| } | |
| else case404() | |
| def case406(): Unit = | |
| if x117.isInstanceOf[Foo02] then | |
| { | |
| case val x442: Foo02 = x117.asInstanceOf[Foo02] | |
| case val x443: Foo02 = Foo02.unapply(x442) | |
| case val x444: Int = x443._1() | |
| if 1.==(x444) then | |
| { | |
| case val x445: Int = x443._2() | |
| if 2.==(x445) then | |
| { | |
| case val x446: Int = x443._3() | |
| if 3.==(x446) then | |
| { | |
| case val x447: Int = x443._4() | |
| if 4.==(x447) then | |
| { | |
| case val x448: Int = x443._5() | |
| if 5.==(x448) then | |
| { | |
| case val x449: Int = x443._6() | |
| if 6.==(x449) then | |
| { | |
| case val x450: Int = x443._7() | |
| if 7.==(x450) then | |
| { | |
| case val x451: Int = x443._8() | |
| if 8.==(x451) then | |
| { | |
| case val x452: Int = x443._9() | |
| if 9.==(x452) then | |
| { | |
| case val x453: Int = x443._10() | |
| if 10.==(x453) then | |
| { | |
| Test.stuff() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| } | |
| else case405() | |
| if x117.isInstanceOf[Foo01] then | |
| { | |
| case val x454: Foo01 = x117.asInstanceOf[Foo01] | |
| case val x455: Foo01 = Foo01.unapply(x454) | |
| case val x456: Int = x455._1() | |
| if 1.==(x456) then | |
| { | |
| case val x457: Int = x455._2() | |
| if 2.==(x457) then | |
| { | |
| case val x458: Int = x455._3() | |
| if 3.==(x458) then | |
| { | |
| case val x459: Int = x455._4() | |
| if 4.==(x459) then | |
| { | |
| case val x460: Int = x455._5() | |
| if 5.==(x460) then | |
| { | |
| case val x461: Int = x455._6() | |
| if 6.==(x461) then | |
| { | |
| case val x462: Int = x455._7() | |
| if 7.==(x462) then | |
| { | |
| case val x463: Int = x455._8() | |
| if 8.==(x463) then | |
| { | |
| case val x464: Int = x455._9() | |
| if 9.==(x464) then | |
| { | |
| case val x465: Int = x455._10() | |
| if 10.==(x465) then | |
| { | |
| Test.stuff() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| else case406() | |
| } | |
| ``` |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment