Created
August 22, 2018 15:51
-
-
Save sjrd/803ddf59e4d17a5ffa445e3f3c16dfd4 to your computer and use it in GitHub Desktop.
This file contains hidden or 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
| package <empty> { | |
| final lazy module val foo: foo$ = new foo$() | |
| @scala.annotation.internal.SourceFile("tests/pos/t10387b.scala") final module | |
| class | |
| foo$() extends Object() { | |
| @scala.annotation.internal.Child[foo.Bit1]() @ | |
| scala.annotation.internal.Child | |
| [foo.Bit0]() @scala.annotation.internal.Child[foo.One]() sealed abstract | |
| class | |
| num() extends Object() {} | |
| final case class One() extends foo.num() with Product { | |
| def copy(): foo.One = new foo.One() | |
| override def hashCode(): Int = 2115070284 | |
| override def equals(x$0: Any): Boolean = | |
| this.eq(x$0.asInstanceOf[Object]).||( | |
| matchResult1[Boolean]: | |
| { | |
| case val x1: Any(x$0) = x$0 | |
| if x1.$isInstanceOf$[foo.One @unchecked] then | |
| { | |
| case val x2: foo.One @unchecked = | |
| x1.asInstanceOf[foo.One @unchecked] | |
| val x$0: foo.One = x2 | |
| return[matchResult1] true | |
| } | |
| else () | |
| return[matchResult1] false | |
| return[matchResult1] throw new MatchError(x1) | |
| } | |
| ) | |
| override def toString(): String = | |
| scala.runtime.ScalaRunTime._toString(this) | |
| override def canEqual(that: Any): Boolean = | |
| that.isInstanceOf[foo.One @unchecked] | |
| override def productArity: Int = 0 | |
| override def productPrefix: String = "One" | |
| override def productElement(n: Int): Any = | |
| matchResult2[Nothing]: | |
| { | |
| case val x3: Int(n) = n | |
| return[matchResult2] | |
| throw new IndexOutOfBoundsException(n.toString()) | |
| return[matchResult2] throw new MatchError(x3) | |
| } | |
| } | |
| final lazy module val One: foo.One$ = new foo.One$() | |
| final module class One$() extends Object() with (() => foo.One) { | |
| def apply(): foo.One = new foo.One() | |
| def unapply(x$1: foo.One): Boolean = true | |
| } | |
| final case class Bit0(a: foo.num) extends foo.num() with Product { | |
| val a: foo.num | |
| def copy(a: foo.num): foo.Bit0 = new foo.Bit0(a) | |
| def copy$default$1: foo.num = | |
| Bit0.this.a: foo.num(Bit0.this.a) @uncheckedVariance | |
| def _1: foo.num = this.a | |
| override def hashCode(): Int = | |
| { | |
| var acc: Int = 1305520307 | |
| acc = | |
| scala.runtime.Statics$#mix(acc, | |
| scala.runtime.Statics$#anyHash(Bit0.this.a) | |
| ) | |
| scala.runtime.Statics$#finalizeHash(acc, 1) | |
| } | |
| override def equals(x$0: Any): Boolean = | |
| this.eq(x$0.asInstanceOf[Object]).||( | |
| matchResult3[Boolean]: | |
| { | |
| case val x4: Any(x$0) = x$0 | |
| if x4.$isInstanceOf$[foo.Bit0 @unchecked] then | |
| { | |
| case val x5: foo.Bit0 @unchecked = | |
| x4.asInstanceOf[foo.Bit0 @unchecked] | |
| val x$0: foo.Bit0 = x5 | |
| return[matchResult3] this.a.==(x$0.a) | |
| } | |
| else () | |
| return[matchResult3] false | |
| return[matchResult3] throw new MatchError(x4) | |
| } | |
| ) | |
| override def toString(): String = | |
| scala.runtime.ScalaRunTime._toString(this) | |
| override def canEqual(that: Any): Boolean = | |
| that.isInstanceOf[foo.Bit0 @unchecked] | |
| override def productArity: Int = 1 | |
| override def productPrefix: String = "Bit0" | |
| override def productElement(n: Int): Any = | |
| matchResult4[=> foo.num(Bit0.this._1)]: | |
| { | |
| case val x6: Int(n) = n | |
| if 0.==(x6) then return[matchResult4] this._1 else () | |
| return[matchResult4] | |
| throw new IndexOutOfBoundsException(n.toString()) | |
| return[matchResult4] throw new MatchError(x6) | |
| } | |
| } | |
| final lazy module val Bit0: foo.Bit0$ = new foo.Bit0$() | |
| final module class Bit0$() extends Object() with (foo.num => foo.Bit0) { | |
| def apply(a: foo.num): foo.Bit0 = new foo.Bit0(a) | |
| def unapply(x$1: foo.Bit0): foo.Bit0 = x$1 | |
| } | |
| final case class Bit1(a: foo.num) extends foo.num() with Product { | |
| val a: foo.num | |
| def copy(a: foo.num): foo.Bit1 = new foo.Bit1(a) | |
| def copy$default$1: foo.num = | |
| Bit1.this.a: foo.num(Bit1.this.a) @uncheckedVariance | |
| def _1: foo.num = this.a | |
| override def hashCode(): Int = | |
| { | |
| var acc: Int = 1305520308 | |
| acc = | |
| scala.runtime.Statics$#mix(acc, | |
| scala.runtime.Statics$#anyHash(Bit1.this.a) | |
| ) | |
| scala.runtime.Statics$#finalizeHash(acc, 1) | |
| } | |
| override def equals(x$0: Any): Boolean = | |
| this.eq(x$0.asInstanceOf[Object]).||( | |
| matchResult5[Boolean]: | |
| { | |
| case val x7: Any(x$0) = x$0 | |
| if x7.$isInstanceOf$[foo.Bit1 @unchecked] then | |
| { | |
| case val x8: foo.Bit1 @unchecked = | |
| x7.asInstanceOf[foo.Bit1 @unchecked] | |
| val x$0: foo.Bit1 = x8 | |
| return[matchResult5] this.a.==(x$0.a) | |
| } | |
| else () | |
| return[matchResult5] false | |
| return[matchResult5] throw new MatchError(x7) | |
| } | |
| ) | |
| override def toString(): String = | |
| scala.runtime.ScalaRunTime._toString(this) | |
| override def canEqual(that: Any): Boolean = | |
| that.isInstanceOf[foo.Bit1 @unchecked] | |
| override def productArity: Int = 1 | |
| override def productPrefix: String = "Bit1" | |
| override def productElement(n: Int): Any = | |
| matchResult6[=> foo.num(Bit1.this._1)]: | |
| { | |
| case val x9: Int(n) = n | |
| if 0.==(x9) then return[matchResult6] this._1 else () | |
| return[matchResult6] | |
| throw new IndexOutOfBoundsException(n.toString()) | |
| return[matchResult6] throw new MatchError(x9) | |
| } | |
| } | |
| final lazy module val Bit1: foo.Bit1$ = new foo.Bit1$() | |
| final module class Bit1$() extends Object() with (foo.num => foo.Bit1) { | |
| def apply(a: foo.num): foo.Bit1 = new foo.Bit1(a) | |
| def unapply(x$1: foo.Bit1): foo.Bit1 = x$1 | |
| } | |
| @scala.annotation.internal.Child[foo.Char]() @ | |
| scala.annotation.internal.Child | |
| [foo.zero_char]() sealed abstract class char() extends Object() {} | |
| final case class zero_char() extends foo.char() with Product { | |
| def copy(): foo.zero_char = new foo.zero_char() | |
| override def hashCode(): Int = -816973378 | |
| override def equals(x$0: Any): Boolean = | |
| this.eq(x$0.asInstanceOf[Object]).||( | |
| matchResult7[Boolean]: | |
| { | |
| case val x10: Any(x$0) = x$0 | |
| if x10.$isInstanceOf$[foo.zero_char @unchecked] then | |
| { | |
| case val x11: foo.zero_char @unchecked = | |
| x10.asInstanceOf[foo.zero_char @unchecked] | |
| val x$0: foo.zero_char = x11 | |
| return[matchResult7] true | |
| } | |
| else () | |
| return[matchResult7] false | |
| return[matchResult7] throw new MatchError(x10) | |
| } | |
| ) | |
| override def toString(): String = | |
| scala.runtime.ScalaRunTime._toString(this) | |
| override def canEqual(that: Any): Boolean = | |
| that.isInstanceOf[foo.zero_char @unchecked] | |
| override def productArity: Int = 0 | |
| override def productPrefix: String = "zero_char" | |
| override def productElement(n: Int): Any = | |
| matchResult8[Nothing]: | |
| { | |
| case val x12: Int(n) = n | |
| return[matchResult8] | |
| throw new IndexOutOfBoundsException(n.toString()) | |
| return[matchResult8] throw new MatchError(x12) | |
| } | |
| } | |
| final lazy module val zero_char: foo.zero_char$ = new foo.zero_char$() | |
| final module class zero_char$() extends Object() with (() => foo.zero_char) | |
| { | |
| def apply(): foo.zero_char = new foo.zero_char() | |
| def unapply(x$1: foo.zero_char): Boolean = true | |
| } | |
| final case class Char(a: foo.num) extends foo.char() with Product { | |
| val a: foo.num | |
| def copy(a: foo.num): foo.Char = new foo.Char(a) | |
| def copy$default$1: foo.num = | |
| Char.this.a: foo.num(Char.this.a) @uncheckedVariance | |
| def _1: foo.num = this.a | |
| override def hashCode(): Int = | |
| { | |
| var acc: Int = 1305548614 | |
| acc = | |
| scala.runtime.Statics$#mix(acc, | |
| scala.runtime.Statics$#anyHash(Char.this.a) | |
| ) | |
| scala.runtime.Statics$#finalizeHash(acc, 1) | |
| } | |
| override def equals(x$0: Any): Boolean = | |
| this.eq(x$0.asInstanceOf[Object]).||( | |
| matchResult9[Boolean]: | |
| { | |
| case val x13: Any(x$0) = x$0 | |
| if x13.$isInstanceOf$[foo.Char @unchecked] then | |
| { | |
| case val x14: foo.Char @unchecked = | |
| x13.asInstanceOf[foo.Char @unchecked] | |
| val x$0: foo.Char = x14 | |
| return[matchResult9] this.a.==(x$0.a) | |
| } | |
| else () | |
| return[matchResult9] false | |
| return[matchResult9] throw new MatchError(x13) | |
| } | |
| ) | |
| override def toString(): String = | |
| scala.runtime.ScalaRunTime._toString(this) | |
| override def canEqual(that: Any): Boolean = | |
| that.isInstanceOf[foo.Char @unchecked] | |
| override def productArity: Int = 1 | |
| override def productPrefix: String = "Char" | |
| override def productElement(n: Int): Any = | |
| matchResult10[=> foo.num(Char.this._1)]: | |
| { | |
| case val x15: Int(n) = n | |
| if 0.==(x15) then return[matchResult10] this._1 else () | |
| return[matchResult10] | |
| throw new IndexOutOfBoundsException(n.toString()) | |
| return[matchResult10] throw new MatchError(x15) | |
| } | |
| } | |
| final lazy module val Char: foo.Char$ = new foo.Char$() | |
| final module class Char$() extends Object() with (foo.num => foo.Char) { | |
| def apply(a: foo.num): foo.Char = new foo.Char(a) | |
| def unapply(x$1: foo.Char): foo.Char = x$1 | |
| } | |
| def integer_of_char(x0: foo.char): BigInt = | |
| matchResult11[BigInt]: | |
| { | |
| case val x16: foo.char(x0) = x0 | |
| if x16.$isInstanceOf$[foo.Char] then | |
| { | |
| case val x5627: foo.Char = x16.asInstanceOf[foo.Char] | |
| case val x5628: foo.Char = foo.Char.unapply(x5627) | |
| case val x5629: foo.num = x5628._1 | |
| if x5629.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5630: foo.Bit0 = x5629.asInstanceOf[foo.Bit0] | |
| case val x5631: foo.Bit0 = foo.Bit0.unapply(x5630) | |
| case val x5632: foo.num = x5631._1 | |
| if x5632.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5633: foo.Bit0 = x5632.asInstanceOf[foo.Bit0] | |
| case val x5634: foo.Bit0 = foo.Bit0.unapply(x5633) | |
| case val x5635: foo.num = x5634._1 | |
| if x5635.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5636: foo.Bit0 = | |
| x5635.asInstanceOf[foo.Bit0] | |
| case val x5637: foo.Bit0 = foo.Bit0.unapply(x5636) | |
| case val x5638: foo.num = x5637._1 | |
| if x5638.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5639: foo.Bit0 = | |
| x5638.asInstanceOf[foo.Bit0] | |
| case val x5640: foo.Bit0 = foo.Bit0.unapply(x5639) | |
| case val x5641: foo.num = x5640._1 | |
| if x5641.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5642: foo.Bit0 = | |
| x5641.asInstanceOf[foo.Bit0] | |
| case val x5643: foo.Bit0 = | |
| foo.Bit0.unapply(x5642) | |
| case val x5644: foo.num = x5643._1 | |
| if x5644.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5645: foo.Bit0 = | |
| x5644.asInstanceOf[foo.Bit0] | |
| case val x5646: foo.Bit0 = | |
| foo.Bit0.unapply(x5645) | |
| case val x5647: foo.num = x5646._1 | |
| if x5647.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5648: foo.Bit0 = | |
| x5647.asInstanceOf[foo.Bit0] | |
| case val x5649: foo.Bit0 = | |
| foo.Bit0.unapply(x5648) | |
| case val x5650: foo.num = x5649._1 | |
| if x5650.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5651: foo.One = | |
| x5650.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5651) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(128) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5647.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5623: foo.Bit1 = | |
| x5647.asInstanceOf[foo.Bit1] | |
| case val x5624: foo.Bit1 = | |
| foo.Bit1.unapply(x5623) | |
| case val x5625: foo.num = x5624._1 | |
| if x5625.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5626: foo.One = | |
| x5625.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5626) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(192) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5647.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5601: foo.One = | |
| x5647.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5601) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(64) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5644.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5573: foo.Bit1 = | |
| x5644.asInstanceOf[foo.Bit1] | |
| case val x5574: foo.Bit1 = | |
| foo.Bit1.unapply(x5573) | |
| case val x5575: foo.num = x5574._1 | |
| if x5575.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5576: foo.Bit0 = | |
| x5575.asInstanceOf[foo.Bit0] | |
| case val x5577: foo.Bit0 = | |
| foo.Bit0.unapply(x5576) | |
| case val x5578: foo.num = x5577._1 | |
| if x5578.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5579: foo.One = | |
| x5578.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5579) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(160) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5575.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5551: foo.Bit1 = | |
| x5575.asInstanceOf[foo.Bit1] | |
| case val x5552: foo.Bit1 = | |
| foo.Bit1.unapply(x5551) | |
| case val x5553: foo.num = x5552._1 | |
| if x5553.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5554: foo.One = | |
| x5553.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5554) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(224) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5575.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5529: foo.One = | |
| x5575.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5529) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(96) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5644.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5507: foo.One = | |
| x5644.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5507) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(32) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5641.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5479: foo.Bit1 = | |
| x5641.asInstanceOf[foo.Bit1] | |
| case val x5480: foo.Bit1 = | |
| foo.Bit1.unapply(x5479) | |
| case val x5481: foo.num = x5480._1 | |
| if x5481.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5482: foo.Bit0 = | |
| x5481.asInstanceOf[foo.Bit0] | |
| case val x5483: foo.Bit0 = | |
| foo.Bit0.unapply(x5482) | |
| case val x5484: foo.num = x5483._1 | |
| if x5484.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5485: foo.Bit0 = | |
| x5484.asInstanceOf[foo.Bit0] | |
| case val x5486: foo.Bit0 = | |
| foo.Bit0.unapply(x5485) | |
| case val x5487: foo.num = x5486._1 | |
| if x5487.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5488: foo.One = | |
| x5487.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5488) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(144) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5484.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5460: foo.Bit1 = | |
| x5484.asInstanceOf[foo.Bit1] | |
| case val x5461: foo.Bit1 = | |
| foo.Bit1.unapply(x5460) | |
| case val x5462: foo.num = x5461._1 | |
| if x5462.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5463: foo.One = | |
| x5462.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5463) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(208) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5484.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5438: foo.One = | |
| x5484.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5438) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(80) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5481.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5410: foo.Bit1 = | |
| x5481.asInstanceOf[foo.Bit1] | |
| case val x5411: foo.Bit1 = | |
| foo.Bit1.unapply(x5410) | |
| case val x5412: foo.num = x5411._1 | |
| if x5412.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5413: foo.Bit0 = | |
| x5412.asInstanceOf[foo.Bit0] | |
| case val x5414: foo.Bit0 = | |
| foo.Bit0.unapply(x5413) | |
| case val x5415: foo.num = x5414._1 | |
| if x5415.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5416: foo.One = | |
| x5415.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5416) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(176) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5412.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5388: foo.Bit1 = | |
| x5412.asInstanceOf[foo.Bit1] | |
| case val x5389: foo.Bit1 = | |
| foo.Bit1.unapply(x5388) | |
| case val x5390: foo.num = x5389._1 | |
| if x5390.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5391: foo.One = | |
| x5390.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5391) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(240) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5412.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5366: foo.One = | |
| x5412.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5366) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(112) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5481.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5344: foo.One = | |
| x5481.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5344) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(48) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5641.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5325: foo.One = | |
| x5641.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5325) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(16) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5638.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5297: foo.Bit1 = | |
| x5638.asInstanceOf[foo.Bit1] | |
| case val x5298: foo.Bit1 = foo.Bit1.unapply(x5297) | |
| case val x5299: foo.num = x5298._1 | |
| if x5299.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5300: foo.Bit0 = | |
| x5299.asInstanceOf[foo.Bit0] | |
| case val x5301: foo.Bit0 = | |
| foo.Bit0.unapply(x5300) | |
| case val x5302: foo.num = x5301._1 | |
| if x5302.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5303: foo.Bit0 = | |
| x5302.asInstanceOf[foo.Bit0] | |
| case val x5304: foo.Bit0 = | |
| foo.Bit0.unapply(x5303) | |
| case val x5305: foo.num = x5304._1 | |
| if x5305.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5306: foo.Bit0 = | |
| x5305.asInstanceOf[foo.Bit0] | |
| case val x5307: foo.Bit0 = | |
| foo.Bit0.unapply(x5306) | |
| case val x5308: foo.num = x5307._1 | |
| if x5308.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5309: foo.One = | |
| x5308.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5309) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(136) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5305.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5281: foo.Bit1 = | |
| x5305.asInstanceOf[foo.Bit1] | |
| case val x5282: foo.Bit1 = | |
| foo.Bit1.unapply(x5281) | |
| case val x5283: foo.num = x5282._1 | |
| if x5283.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5284: foo.One = | |
| x5283.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5284) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(200) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5305.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5259: foo.One = | |
| x5305.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5259) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(72) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5302.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5231: foo.Bit1 = | |
| x5302.asInstanceOf[foo.Bit1] | |
| case val x5232: foo.Bit1 = | |
| foo.Bit1.unapply(x5231) | |
| case val x5233: foo.num = x5232._1 | |
| if x5233.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5234: foo.Bit0 = | |
| x5233.asInstanceOf[foo.Bit0] | |
| case val x5235: foo.Bit0 = | |
| foo.Bit0.unapply(x5234) | |
| case val x5236: foo.num = x5235._1 | |
| if x5236.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5237: foo.One = | |
| x5236.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5237) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(168) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5233.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5209: foo.Bit1 = | |
| x5233.asInstanceOf[foo.Bit1] | |
| case val x5210: foo.Bit1 = | |
| foo.Bit1.unapply(x5209) | |
| case val x5211: foo.num = x5210._1 | |
| if x5211.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5212: foo.One = | |
| x5211.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5212) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(232) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5233.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5187: foo.One = | |
| x5233.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5187) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(104) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5302.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5165: foo.One = | |
| x5302.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5165) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(40) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5299.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5137: foo.Bit1 = | |
| x5299.asInstanceOf[foo.Bit1] | |
| case val x5138: foo.Bit1 = | |
| foo.Bit1.unapply(x5137) | |
| case val x5139: foo.num = x5138._1 | |
| if x5139.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5140: foo.Bit0 = | |
| x5139.asInstanceOf[foo.Bit0] | |
| case val x5141: foo.Bit0 = | |
| foo.Bit0.unapply(x5140) | |
| case val x5142: foo.num = x5141._1 | |
| if x5142.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5143: foo.Bit0 = | |
| x5142.asInstanceOf[foo.Bit0] | |
| case val x5144: foo.Bit0 = | |
| foo.Bit0.unapply(x5143) | |
| case val x5145: foo.num = x5144._1 | |
| if x5145.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5146: foo.One = | |
| x5145.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5146) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(152) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5142.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5118: foo.Bit1 = | |
| x5142.asInstanceOf[foo.Bit1] | |
| case val x5119: foo.Bit1 = | |
| foo.Bit1.unapply(x5118) | |
| case val x5120: foo.num = x5119._1 | |
| if x5120.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5121: foo.One = | |
| x5120.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5121) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(216) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5142.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5096: foo.One = | |
| x5142.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5096) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(88) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5139.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5068: foo.Bit1 = | |
| x5139.asInstanceOf[foo.Bit1] | |
| case val x5069: foo.Bit1 = | |
| foo.Bit1.unapply(x5068) | |
| case val x5070: foo.num = x5069._1 | |
| if x5070.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x5071: foo.Bit0 = | |
| x5070.asInstanceOf[foo.Bit0] | |
| case val x5072: foo.Bit0 = | |
| foo.Bit0.unapply(x5071) | |
| case val x5073: foo.num = x5072._1 | |
| if x5073.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5074: foo.One = | |
| x5073.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5074) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(184) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5070.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x5046: foo.Bit1 = | |
| x5070.asInstanceOf[foo.Bit1] | |
| case val x5047: foo.Bit1 = | |
| foo.Bit1.unapply(x5046) | |
| case val x5048: foo.num = x5047._1 | |
| if x5048.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5049: foo.One = | |
| x5048.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5049) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(248) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5070.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5024: foo.One = | |
| x5070.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5024) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(120) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5139.$isInstanceOf$[foo.One] then | |
| { | |
| case val x5002: foo.One = | |
| x5139.asInstanceOf[foo.One] | |
| if foo.One.unapply(x5002) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(56) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5299.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4983: foo.One = | |
| x5299.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4983) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(24) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5638.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4967: foo.One = | |
| x5638.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4967) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(8) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5635.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4939: foo.Bit1 = | |
| x5635.asInstanceOf[foo.Bit1] | |
| case val x4940: foo.Bit1 = foo.Bit1.unapply(x4939) | |
| case val x4941: foo.num = x4940._1 | |
| if x4941.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4942: foo.Bit0 = | |
| x4941.asInstanceOf[foo.Bit0] | |
| case val x4943: foo.Bit0 = foo.Bit0.unapply(x4942) | |
| case val x4944: foo.num = x4943._1 | |
| if x4944.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4945: foo.Bit0 = | |
| x4944.asInstanceOf[foo.Bit0] | |
| case val x4946: foo.Bit0 = | |
| foo.Bit0.unapply(x4945) | |
| case val x4947: foo.num = x4946._1 | |
| if x4947.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4948: foo.Bit0 = | |
| x4947.asInstanceOf[foo.Bit0] | |
| case val x4949: foo.Bit0 = | |
| foo.Bit0.unapply(x4948) | |
| case val x4950: foo.num = x4949._1 | |
| if x4950.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4951: foo.Bit0 = | |
| x4950.asInstanceOf[foo.Bit0] | |
| case val x4952: foo.Bit0 = | |
| foo.Bit0.unapply(x4951) | |
| case val x4953: foo.num = x4952._1 | |
| if x4953.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4954: foo.One = | |
| x4953.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4954) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(132) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4950.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4926: foo.Bit1 = | |
| x4950.asInstanceOf[foo.Bit1] | |
| case val x4927: foo.Bit1 = | |
| foo.Bit1.unapply(x4926) | |
| case val x4928: foo.num = x4927._1 | |
| if x4928.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4929: foo.One = | |
| x4928.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4929) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(196) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4950.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4904: foo.One = | |
| x4950.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4904) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(68) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4947.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4876: foo.Bit1 = | |
| x4947.asInstanceOf[foo.Bit1] | |
| case val x4877: foo.Bit1 = | |
| foo.Bit1.unapply(x4876) | |
| case val x4878: foo.num = x4877._1 | |
| if x4878.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4879: foo.Bit0 = | |
| x4878.asInstanceOf[foo.Bit0] | |
| case val x4880: foo.Bit0 = | |
| foo.Bit0.unapply(x4879) | |
| case val x4881: foo.num = x4880._1 | |
| if x4881.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4882: foo.One = | |
| x4881.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4882) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(164) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4878.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4854: foo.Bit1 = | |
| x4878.asInstanceOf[foo.Bit1] | |
| case val x4855: foo.Bit1 = | |
| foo.Bit1.unapply(x4854) | |
| case val x4856: foo.num = x4855._1 | |
| if x4856.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4857: foo.One = | |
| x4856.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4857) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(228) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4878.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4832: foo.One = | |
| x4878.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4832) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(100) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4947.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4810: foo.One = | |
| x4947.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4810) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(36) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4944.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4782: foo.Bit1 = | |
| x4944.asInstanceOf[foo.Bit1] | |
| case val x4783: foo.Bit1 = | |
| foo.Bit1.unapply(x4782) | |
| case val x4784: foo.num = x4783._1 | |
| if x4784.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4785: foo.Bit0 = | |
| x4784.asInstanceOf[foo.Bit0] | |
| case val x4786: foo.Bit0 = | |
| foo.Bit0.unapply(x4785) | |
| case val x4787: foo.num = x4786._1 | |
| if x4787.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4788: foo.Bit0 = | |
| x4787.asInstanceOf[foo.Bit0] | |
| case val x4789: foo.Bit0 = | |
| foo.Bit0.unapply(x4788) | |
| case val x4790: foo.num = x4789._1 | |
| if x4790.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4791: foo.One = | |
| x4790.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4791) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(148) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4787.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4763: foo.Bit1 = | |
| x4787.asInstanceOf[foo.Bit1] | |
| case val x4764: foo.Bit1 = | |
| foo.Bit1.unapply(x4763) | |
| case val x4765: foo.num = x4764._1 | |
| if x4765.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4766: foo.One = | |
| x4765.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4766) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(212) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4787.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4741: foo.One = | |
| x4787.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4741) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(84) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4784.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4713: foo.Bit1 = | |
| x4784.asInstanceOf[foo.Bit1] | |
| case val x4714: foo.Bit1 = | |
| foo.Bit1.unapply(x4713) | |
| case val x4715: foo.num = x4714._1 | |
| if x4715.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4716: foo.Bit0 = | |
| x4715.asInstanceOf[foo.Bit0] | |
| case val x4717: foo.Bit0 = | |
| foo.Bit0.unapply(x4716) | |
| case val x4718: foo.num = x4717._1 | |
| if x4718.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4719: foo.One = | |
| x4718.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4719) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(180) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4715.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4691: foo.Bit1 = | |
| x4715.asInstanceOf[foo.Bit1] | |
| case val x4692: foo.Bit1 = | |
| foo.Bit1.unapply(x4691) | |
| case val x4693: foo.num = x4692._1 | |
| if x4693.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4694: foo.One = | |
| x4693.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4694) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(244) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4715.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4669: foo.One = | |
| x4715.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4669) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(116) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4784.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4647: foo.One = | |
| x4784.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4647) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(52) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4944.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4628: foo.One = | |
| x4944.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4628) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(20) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4941.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4600: foo.Bit1 = | |
| x4941.asInstanceOf[foo.Bit1] | |
| case val x4601: foo.Bit1 = foo.Bit1.unapply(x4600) | |
| case val x4602: foo.num = x4601._1 | |
| if x4602.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4603: foo.Bit0 = | |
| x4602.asInstanceOf[foo.Bit0] | |
| case val x4604: foo.Bit0 = | |
| foo.Bit0.unapply(x4603) | |
| case val x4605: foo.num = x4604._1 | |
| if x4605.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4606: foo.Bit0 = | |
| x4605.asInstanceOf[foo.Bit0] | |
| case val x4607: foo.Bit0 = | |
| foo.Bit0.unapply(x4606) | |
| case val x4608: foo.num = x4607._1 | |
| if x4608.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4609: foo.Bit0 = | |
| x4608.asInstanceOf[foo.Bit0] | |
| case val x4610: foo.Bit0 = | |
| foo.Bit0.unapply(x4609) | |
| case val x4611: foo.num = x4610._1 | |
| if x4611.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4612: foo.One = | |
| x4611.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4612) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(140) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4608.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4584: foo.Bit1 = | |
| x4608.asInstanceOf[foo.Bit1] | |
| case val x4585: foo.Bit1 = | |
| foo.Bit1.unapply(x4584) | |
| case val x4586: foo.num = x4585._1 | |
| if x4586.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4587: foo.One = | |
| x4586.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4587) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(204) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4608.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4562: foo.One = | |
| x4608.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4562) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(76) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4605.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4534: foo.Bit1 = | |
| x4605.asInstanceOf[foo.Bit1] | |
| case val x4535: foo.Bit1 = | |
| foo.Bit1.unapply(x4534) | |
| case val x4536: foo.num = x4535._1 | |
| if x4536.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4537: foo.Bit0 = | |
| x4536.asInstanceOf[foo.Bit0] | |
| case val x4538: foo.Bit0 = | |
| foo.Bit0.unapply(x4537) | |
| case val x4539: foo.num = x4538._1 | |
| if x4539.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4540: foo.One = | |
| x4539.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4540) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(172) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4536.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4512: foo.Bit1 = | |
| x4536.asInstanceOf[foo.Bit1] | |
| case val x4513: foo.Bit1 = | |
| foo.Bit1.unapply(x4512) | |
| case val x4514: foo.num = x4513._1 | |
| if x4514.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4515: foo.One = | |
| x4514.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4515) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(236) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4536.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4490: foo.One = | |
| x4536.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4490) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(108) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4605.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4468: foo.One = | |
| x4605.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4468) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(44) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4602.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4440: foo.Bit1 = | |
| x4602.asInstanceOf[foo.Bit1] | |
| case val x4441: foo.Bit1 = | |
| foo.Bit1.unapply(x4440) | |
| case val x4442: foo.num = x4441._1 | |
| if x4442.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4443: foo.Bit0 = | |
| x4442.asInstanceOf[foo.Bit0] | |
| case val x4444: foo.Bit0 = | |
| foo.Bit0.unapply(x4443) | |
| case val x4445: foo.num = x4444._1 | |
| if x4445.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4446: foo.Bit0 = | |
| x4445.asInstanceOf[foo.Bit0] | |
| case val x4447: foo.Bit0 = | |
| foo.Bit0.unapply(x4446) | |
| case val x4448: foo.num = x4447._1 | |
| if x4448.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4449: foo.One = | |
| x4448.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4449) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(156) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4445.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4421: foo.Bit1 = | |
| x4445.asInstanceOf[foo.Bit1] | |
| case val x4422: foo.Bit1 = | |
| foo.Bit1.unapply(x4421) | |
| case val x4423: foo.num = x4422._1 | |
| if x4423.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4424: foo.One = | |
| x4423.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4424) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(220) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4445.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4399: foo.One = | |
| x4445.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4399) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(92) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4442.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4371: foo.Bit1 = | |
| x4442.asInstanceOf[foo.Bit1] | |
| case val x4372: foo.Bit1 = | |
| foo.Bit1.unapply(x4371) | |
| case val x4373: foo.num = x4372._1 | |
| if x4373.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4374: foo.Bit0 = | |
| x4373.asInstanceOf[foo.Bit0] | |
| case val x4375: foo.Bit0 = | |
| foo.Bit0.unapply(x4374) | |
| case val x4376: foo.num = x4375._1 | |
| if x4376.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4377: foo.One = | |
| x4376.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4377) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(188) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4373.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4349: foo.Bit1 = | |
| x4373.asInstanceOf[foo.Bit1] | |
| case val x4350: foo.Bit1 = | |
| foo.Bit1.unapply(x4349) | |
| case val x4351: foo.num = x4350._1 | |
| if x4351.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4352: foo.One = | |
| x4351.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4352) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(252) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4373.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4327: foo.One = | |
| x4373.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4327) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(124) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4442.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4305: foo.One = | |
| x4442.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4305) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(60) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4602.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4286: foo.One = | |
| x4602.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4286) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(28) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4941.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4270: foo.One = | |
| x4941.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4270) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(12) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5635.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4257: foo.One = x5635.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4257) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(4) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5632.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4229: foo.Bit1 = x5632.asInstanceOf[foo.Bit1] | |
| case val x4230: foo.Bit1 = foo.Bit1.unapply(x4229) | |
| case val x4231: foo.num = x4230._1 | |
| if x4231.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4232: foo.Bit0 = | |
| x4231.asInstanceOf[foo.Bit0] | |
| case val x4233: foo.Bit0 = foo.Bit0.unapply(x4232) | |
| case val x4234: foo.num = x4233._1 | |
| if x4234.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4235: foo.Bit0 = | |
| x4234.asInstanceOf[foo.Bit0] | |
| case val x4236: foo.Bit0 = foo.Bit0.unapply(x4235) | |
| case val x4237: foo.num = x4236._1 | |
| if x4237.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4238: foo.Bit0 = | |
| x4237.asInstanceOf[foo.Bit0] | |
| case val x4239: foo.Bit0 = | |
| foo.Bit0.unapply(x4238) | |
| case val x4240: foo.num = x4239._1 | |
| if x4240.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4241: foo.Bit0 = | |
| x4240.asInstanceOf[foo.Bit0] | |
| case val x4242: foo.Bit0 = | |
| foo.Bit0.unapply(x4241) | |
| case val x4243: foo.num = x4242._1 | |
| if x4243.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4244: foo.Bit0 = | |
| x4243.asInstanceOf[foo.Bit0] | |
| case val x4245: foo.Bit0 = | |
| foo.Bit0.unapply(x4244) | |
| case val x4246: foo.num = x4245._1 | |
| if x4246.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4247: foo.One = | |
| x4246.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4247) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(130) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4243.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4219: foo.Bit1 = | |
| x4243.asInstanceOf[foo.Bit1] | |
| case val x4220: foo.Bit1 = | |
| foo.Bit1.unapply(x4219) | |
| case val x4221: foo.num = x4220._1 | |
| if x4221.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4222: foo.One = | |
| x4221.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4222) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(194) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4243.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4197: foo.One = | |
| x4243.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4197) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(66) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4240.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4169: foo.Bit1 = | |
| x4240.asInstanceOf[foo.Bit1] | |
| case val x4170: foo.Bit1 = | |
| foo.Bit1.unapply(x4169) | |
| case val x4171: foo.num = x4170._1 | |
| if x4171.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4172: foo.Bit0 = | |
| x4171.asInstanceOf[foo.Bit0] | |
| case val x4173: foo.Bit0 = | |
| foo.Bit0.unapply(x4172) | |
| case val x4174: foo.num = x4173._1 | |
| if x4174.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4175: foo.One = | |
| x4174.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4175) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(162) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4171.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4147: foo.Bit1 = | |
| x4171.asInstanceOf[foo.Bit1] | |
| case val x4148: foo.Bit1 = | |
| foo.Bit1.unapply(x4147) | |
| case val x4149: foo.num = x4148._1 | |
| if x4149.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4150: foo.One = | |
| x4149.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4150) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(226) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4171.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4125: foo.One = | |
| x4171.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4125) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(98) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4240.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4103: foo.One = | |
| x4240.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4103) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(34) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4237.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4075: foo.Bit1 = | |
| x4237.asInstanceOf[foo.Bit1] | |
| case val x4076: foo.Bit1 = | |
| foo.Bit1.unapply(x4075) | |
| case val x4077: foo.num = x4076._1 | |
| if x4077.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4078: foo.Bit0 = | |
| x4077.asInstanceOf[foo.Bit0] | |
| case val x4079: foo.Bit0 = | |
| foo.Bit0.unapply(x4078) | |
| case val x4080: foo.num = x4079._1 | |
| if x4080.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4081: foo.Bit0 = | |
| x4080.asInstanceOf[foo.Bit0] | |
| case val x4082: foo.Bit0 = | |
| foo.Bit0.unapply(x4081) | |
| case val x4083: foo.num = x4082._1 | |
| if x4083.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4084: foo.One = | |
| x4083.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4084) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(146) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4080.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4056: foo.Bit1 = | |
| x4080.asInstanceOf[foo.Bit1] | |
| case val x4057: foo.Bit1 = | |
| foo.Bit1.unapply(x4056) | |
| case val x4058: foo.num = x4057._1 | |
| if x4058.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4059: foo.One = | |
| x4058.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4059) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(210) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4080.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4034: foo.One = | |
| x4080.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4034) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(82) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4077.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x4006: foo.Bit1 = | |
| x4077.asInstanceOf[foo.Bit1] | |
| case val x4007: foo.Bit1 = | |
| foo.Bit1.unapply(x4006) | |
| case val x4008: foo.num = x4007._1 | |
| if x4008.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x4009: foo.Bit0 = | |
| x4008.asInstanceOf[foo.Bit0] | |
| case val x4010: foo.Bit0 = | |
| foo.Bit0.unapply(x4009) | |
| case val x4011: foo.num = x4010._1 | |
| if x4011.$isInstanceOf$[foo.One] then | |
| { | |
| case val x4012: foo.One = | |
| x4011.asInstanceOf[foo.One] | |
| if foo.One.unapply(x4012) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(178) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4008.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3984: foo.Bit1 = | |
| x4008.asInstanceOf[foo.Bit1] | |
| case val x3985: foo.Bit1 = | |
| foo.Bit1.unapply(x3984) | |
| case val x3986: foo.num = x3985._1 | |
| if x3986.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3987: foo.One = | |
| x3986.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3987) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(242) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4008.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3962: foo.One = | |
| x4008.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3962) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(114) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4077.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3940: foo.One = | |
| x4077.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3940) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(50) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4237.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3921: foo.One = | |
| x4237.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3921) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(18) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4234.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3893: foo.Bit1 = | |
| x4234.asInstanceOf[foo.Bit1] | |
| case val x3894: foo.Bit1 = foo.Bit1.unapply(x3893) | |
| case val x3895: foo.num = x3894._1 | |
| if x3895.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3896: foo.Bit0 = | |
| x3895.asInstanceOf[foo.Bit0] | |
| case val x3897: foo.Bit0 = | |
| foo.Bit0.unapply(x3896) | |
| case val x3898: foo.num = x3897._1 | |
| if x3898.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3899: foo.Bit0 = | |
| x3898.asInstanceOf[foo.Bit0] | |
| case val x3900: foo.Bit0 = | |
| foo.Bit0.unapply(x3899) | |
| case val x3901: foo.num = x3900._1 | |
| if x3901.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3902: foo.Bit0 = | |
| x3901.asInstanceOf[foo.Bit0] | |
| case val x3903: foo.Bit0 = | |
| foo.Bit0.unapply(x3902) | |
| case val x3904: foo.num = x3903._1 | |
| if x3904.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3905: foo.One = | |
| x3904.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3905) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(138) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3901.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3877: foo.Bit1 = | |
| x3901.asInstanceOf[foo.Bit1] | |
| case val x3878: foo.Bit1 = | |
| foo.Bit1.unapply(x3877) | |
| case val x3879: foo.num = x3878._1 | |
| if x3879.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3880: foo.One = | |
| x3879.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3880) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(202) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3901.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3855: foo.One = | |
| x3901.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3855) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(74) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3898.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3827: foo.Bit1 = | |
| x3898.asInstanceOf[foo.Bit1] | |
| case val x3828: foo.Bit1 = | |
| foo.Bit1.unapply(x3827) | |
| case val x3829: foo.num = x3828._1 | |
| if x3829.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3830: foo.Bit0 = | |
| x3829.asInstanceOf[foo.Bit0] | |
| case val x3831: foo.Bit0 = | |
| foo.Bit0.unapply(x3830) | |
| case val x3832: foo.num = x3831._1 | |
| if x3832.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3833: foo.One = | |
| x3832.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3833) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(170) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3829.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3805: foo.Bit1 = | |
| x3829.asInstanceOf[foo.Bit1] | |
| case val x3806: foo.Bit1 = | |
| foo.Bit1.unapply(x3805) | |
| case val x3807: foo.num = x3806._1 | |
| if x3807.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3808: foo.One = | |
| x3807.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3808) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(234) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3829.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3783: foo.One = | |
| x3829.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3783) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(106) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3898.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3761: foo.One = | |
| x3898.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3761) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(42) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3895.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3733: foo.Bit1 = | |
| x3895.asInstanceOf[foo.Bit1] | |
| case val x3734: foo.Bit1 = | |
| foo.Bit1.unapply(x3733) | |
| case val x3735: foo.num = x3734._1 | |
| if x3735.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3736: foo.Bit0 = | |
| x3735.asInstanceOf[foo.Bit0] | |
| case val x3737: foo.Bit0 = | |
| foo.Bit0.unapply(x3736) | |
| case val x3738: foo.num = x3737._1 | |
| if x3738.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3739: foo.Bit0 = | |
| x3738.asInstanceOf[foo.Bit0] | |
| case val x3740: foo.Bit0 = | |
| foo.Bit0.unapply(x3739) | |
| case val x3741: foo.num = x3740._1 | |
| if x3741.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3742: foo.One = | |
| x3741.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3742) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(154) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3738.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3714: foo.Bit1 = | |
| x3738.asInstanceOf[foo.Bit1] | |
| case val x3715: foo.Bit1 = | |
| foo.Bit1.unapply(x3714) | |
| case val x3716: foo.num = x3715._1 | |
| if x3716.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3717: foo.One = | |
| x3716.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3717) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(218) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3738.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3692: foo.One = | |
| x3738.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3692) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(90) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3735.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3664: foo.Bit1 = | |
| x3735.asInstanceOf[foo.Bit1] | |
| case val x3665: foo.Bit1 = | |
| foo.Bit1.unapply(x3664) | |
| case val x3666: foo.num = x3665._1 | |
| if x3666.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3667: foo.Bit0 = | |
| x3666.asInstanceOf[foo.Bit0] | |
| case val x3668: foo.Bit0 = | |
| foo.Bit0.unapply(x3667) | |
| case val x3669: foo.num = x3668._1 | |
| if x3669.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3670: foo.One = | |
| x3669.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3670) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(186) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3666.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3642: foo.Bit1 = | |
| x3666.asInstanceOf[foo.Bit1] | |
| case val x3643: foo.Bit1 = | |
| foo.Bit1.unapply(x3642) | |
| case val x3644: foo.num = x3643._1 | |
| if x3644.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3645: foo.One = | |
| x3644.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3645) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(250) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3666.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3620: foo.One = | |
| x3666.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3620) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(122) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3735.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3598: foo.One = | |
| x3735.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3598) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(58) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3895.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3579: foo.One = | |
| x3895.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3579) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(26) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4234.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3563: foo.One = | |
| x4234.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3563) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(10) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4231.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3535: foo.Bit1 = | |
| x4231.asInstanceOf[foo.Bit1] | |
| case val x3536: foo.Bit1 = foo.Bit1.unapply(x3535) | |
| case val x3537: foo.num = x3536._1 | |
| if x3537.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3538: foo.Bit0 = | |
| x3537.asInstanceOf[foo.Bit0] | |
| case val x3539: foo.Bit0 = foo.Bit0.unapply(x3538) | |
| case val x3540: foo.num = x3539._1 | |
| if x3540.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3541: foo.Bit0 = | |
| x3540.asInstanceOf[foo.Bit0] | |
| case val x3542: foo.Bit0 = | |
| foo.Bit0.unapply(x3541) | |
| case val x3543: foo.num = x3542._1 | |
| if x3543.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3544: foo.Bit0 = | |
| x3543.asInstanceOf[foo.Bit0] | |
| case val x3545: foo.Bit0 = | |
| foo.Bit0.unapply(x3544) | |
| case val x3546: foo.num = x3545._1 | |
| if x3546.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3547: foo.Bit0 = | |
| x3546.asInstanceOf[foo.Bit0] | |
| case val x3548: foo.Bit0 = | |
| foo.Bit0.unapply(x3547) | |
| case val x3549: foo.num = x3548._1 | |
| if x3549.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3550: foo.One = | |
| x3549.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3550) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(134) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3546.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3522: foo.Bit1 = | |
| x3546.asInstanceOf[foo.Bit1] | |
| case val x3523: foo.Bit1 = | |
| foo.Bit1.unapply(x3522) | |
| case val x3524: foo.num = x3523._1 | |
| if x3524.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3525: foo.One = | |
| x3524.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3525) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(198) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3546.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3500: foo.One = | |
| x3546.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3500) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(70) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3543.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3472: foo.Bit1 = | |
| x3543.asInstanceOf[foo.Bit1] | |
| case val x3473: foo.Bit1 = | |
| foo.Bit1.unapply(x3472) | |
| case val x3474: foo.num = x3473._1 | |
| if x3474.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3475: foo.Bit0 = | |
| x3474.asInstanceOf[foo.Bit0] | |
| case val x3476: foo.Bit0 = | |
| foo.Bit0.unapply(x3475) | |
| case val x3477: foo.num = x3476._1 | |
| if x3477.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3478: foo.One = | |
| x3477.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3478) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(166) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3474.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3450: foo.Bit1 = | |
| x3474.asInstanceOf[foo.Bit1] | |
| case val x3451: foo.Bit1 = | |
| foo.Bit1.unapply(x3450) | |
| case val x3452: foo.num = x3451._1 | |
| if x3452.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3453: foo.One = | |
| x3452.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3453) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(230) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3474.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3428: foo.One = | |
| x3474.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3428) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(102) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3543.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3406: foo.One = | |
| x3543.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3406) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(38) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3540.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3378: foo.Bit1 = | |
| x3540.asInstanceOf[foo.Bit1] | |
| case val x3379: foo.Bit1 = | |
| foo.Bit1.unapply(x3378) | |
| case val x3380: foo.num = x3379._1 | |
| if x3380.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3381: foo.Bit0 = | |
| x3380.asInstanceOf[foo.Bit0] | |
| case val x3382: foo.Bit0 = | |
| foo.Bit0.unapply(x3381) | |
| case val x3383: foo.num = x3382._1 | |
| if x3383.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3384: foo.Bit0 = | |
| x3383.asInstanceOf[foo.Bit0] | |
| case val x3385: foo.Bit0 = | |
| foo.Bit0.unapply(x3384) | |
| case val x3386: foo.num = x3385._1 | |
| if x3386.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3387: foo.One = | |
| x3386.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3387) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(150) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3383.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3359: foo.Bit1 = | |
| x3383.asInstanceOf[foo.Bit1] | |
| case val x3360: foo.Bit1 = | |
| foo.Bit1.unapply(x3359) | |
| case val x3361: foo.num = x3360._1 | |
| if x3361.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3362: foo.One = | |
| x3361.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3362) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(214) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3383.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3337: foo.One = | |
| x3383.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3337) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(86) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3380.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3309: foo.Bit1 = | |
| x3380.asInstanceOf[foo.Bit1] | |
| case val x3310: foo.Bit1 = | |
| foo.Bit1.unapply(x3309) | |
| case val x3311: foo.num = x3310._1 | |
| if x3311.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3312: foo.Bit0 = | |
| x3311.asInstanceOf[foo.Bit0] | |
| case val x3313: foo.Bit0 = | |
| foo.Bit0.unapply(x3312) | |
| case val x3314: foo.num = x3313._1 | |
| if x3314.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3315: foo.One = | |
| x3314.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3315) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(182) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3311.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3287: foo.Bit1 = | |
| x3311.asInstanceOf[foo.Bit1] | |
| case val x3288: foo.Bit1 = | |
| foo.Bit1.unapply(x3287) | |
| case val x3289: foo.num = x3288._1 | |
| if x3289.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3290: foo.One = | |
| x3289.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3290) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(246) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3311.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3265: foo.One = | |
| x3311.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3265) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(118) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3380.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3243: foo.One = | |
| x3380.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3243) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(54) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3540.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3224: foo.One = | |
| x3540.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3224) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(22) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3537.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3196: foo.Bit1 = | |
| x3537.asInstanceOf[foo.Bit1] | |
| case val x3197: foo.Bit1 = foo.Bit1.unapply(x3196) | |
| case val x3198: foo.num = x3197._1 | |
| if x3198.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3199: foo.Bit0 = | |
| x3198.asInstanceOf[foo.Bit0] | |
| case val x3200: foo.Bit0 = | |
| foo.Bit0.unapply(x3199) | |
| case val x3201: foo.num = x3200._1 | |
| if x3201.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3202: foo.Bit0 = | |
| x3201.asInstanceOf[foo.Bit0] | |
| case val x3203: foo.Bit0 = | |
| foo.Bit0.unapply(x3202) | |
| case val x3204: foo.num = x3203._1 | |
| if x3204.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3205: foo.Bit0 = | |
| x3204.asInstanceOf[foo.Bit0] | |
| case val x3206: foo.Bit0 = | |
| foo.Bit0.unapply(x3205) | |
| case val x3207: foo.num = x3206._1 | |
| if x3207.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3208: foo.One = | |
| x3207.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3208) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(142) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3204.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3180: foo.Bit1 = | |
| x3204.asInstanceOf[foo.Bit1] | |
| case val x3181: foo.Bit1 = | |
| foo.Bit1.unapply(x3180) | |
| case val x3182: foo.num = x3181._1 | |
| if x3182.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3183: foo.One = | |
| x3182.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3183) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(206) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3204.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3158: foo.One = | |
| x3204.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3158) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(78) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3201.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3130: foo.Bit1 = | |
| x3201.asInstanceOf[foo.Bit1] | |
| case val x3131: foo.Bit1 = | |
| foo.Bit1.unapply(x3130) | |
| case val x3132: foo.num = x3131._1 | |
| if x3132.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3133: foo.Bit0 = | |
| x3132.asInstanceOf[foo.Bit0] | |
| case val x3134: foo.Bit0 = | |
| foo.Bit0.unapply(x3133) | |
| case val x3135: foo.num = x3134._1 | |
| if x3135.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3136: foo.One = | |
| x3135.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3136) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(174) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3132.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3108: foo.Bit1 = | |
| x3132.asInstanceOf[foo.Bit1] | |
| case val x3109: foo.Bit1 = | |
| foo.Bit1.unapply(x3108) | |
| case val x3110: foo.num = x3109._1 | |
| if x3110.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3111: foo.One = | |
| x3110.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3111) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(238) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3132.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3086: foo.One = | |
| x3132.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3086) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(110) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3201.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3064: foo.One = | |
| x3201.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3064) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(46) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3198.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3036: foo.Bit1 = | |
| x3198.asInstanceOf[foo.Bit1] | |
| case val x3037: foo.Bit1 = | |
| foo.Bit1.unapply(x3036) | |
| case val x3038: foo.num = x3037._1 | |
| if x3038.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3039: foo.Bit0 = | |
| x3038.asInstanceOf[foo.Bit0] | |
| case val x3040: foo.Bit0 = | |
| foo.Bit0.unapply(x3039) | |
| case val x3041: foo.num = x3040._1 | |
| if x3041.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x3042: foo.Bit0 = | |
| x3041.asInstanceOf[foo.Bit0] | |
| case val x3043: foo.Bit0 = | |
| foo.Bit0.unapply(x3042) | |
| case val x3044: foo.num = x3043._1 | |
| if x3044.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3045: foo.One = | |
| x3044.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3045) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(158) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3041.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x3017: foo.Bit1 = | |
| x3041.asInstanceOf[foo.Bit1] | |
| case val x3018: foo.Bit1 = | |
| foo.Bit1.unapply(x3017) | |
| case val x3019: foo.num = x3018._1 | |
| if x3019.$isInstanceOf$[foo.One] then | |
| { | |
| case val x3020: foo.One = | |
| x3019.asInstanceOf[foo.One] | |
| if foo.One.unapply(x3020) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(222) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3041.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2995: foo.One = | |
| x3041.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2995) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(94) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3038.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2967: foo.Bit1 = | |
| x3038.asInstanceOf[foo.Bit1] | |
| case val x2968: foo.Bit1 = | |
| foo.Bit1.unapply(x2967) | |
| case val x2969: foo.num = x2968._1 | |
| if x2969.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2970: foo.Bit0 = | |
| x2969.asInstanceOf[foo.Bit0] | |
| case val x2971: foo.Bit0 = | |
| foo.Bit0.unapply(x2970) | |
| case val x2972: foo.num = x2971._1 | |
| if x2972.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2973: foo.One = | |
| x2972.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2973) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(190) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2969.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2945: foo.Bit1 = | |
| x2969.asInstanceOf[foo.Bit1] | |
| case val x2946: foo.Bit1 = | |
| foo.Bit1.unapply(x2945) | |
| case val x2947: foo.num = x2946._1 | |
| if x2947.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2948: foo.One = | |
| x2947.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2948) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(254) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2969.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2923: foo.One = | |
| x2969.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2923) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(126) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3038.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2901: foo.One = | |
| x3038.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2901) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(62) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3198.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2882: foo.One = | |
| x3198.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2882) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(30) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x3537.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2866: foo.One = | |
| x3537.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2866) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(14) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x4231.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2853: foo.One = x4231.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2853) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(6) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5632.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2843: foo.One = x5632.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2843) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(2) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5629.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2815: foo.Bit1 = x5629.asInstanceOf[foo.Bit1] | |
| case val x2816: foo.Bit1 = foo.Bit1.unapply(x2815) | |
| case val x2817: foo.num = x2816._1 | |
| if x2817.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2818: foo.Bit0 = x2817.asInstanceOf[foo.Bit0] | |
| case val x2819: foo.Bit0 = foo.Bit0.unapply(x2818) | |
| case val x2820: foo.num = x2819._1 | |
| if x2820.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2821: foo.Bit0 = | |
| x2820.asInstanceOf[foo.Bit0] | |
| case val x2822: foo.Bit0 = foo.Bit0.unapply(x2821) | |
| case val x2823: foo.num = x2822._1 | |
| if x2823.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2824: foo.Bit0 = | |
| x2823.asInstanceOf[foo.Bit0] | |
| case val x2825: foo.Bit0 = foo.Bit0.unapply(x2824) | |
| case val x2826: foo.num = x2825._1 | |
| if x2826.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2827: foo.Bit0 = | |
| x2826.asInstanceOf[foo.Bit0] | |
| case val x2828: foo.Bit0 = | |
| foo.Bit0.unapply(x2827) | |
| case val x2829: foo.num = x2828._1 | |
| if x2829.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2830: foo.Bit0 = | |
| x2829.asInstanceOf[foo.Bit0] | |
| case val x2831: foo.Bit0 = | |
| foo.Bit0.unapply(x2830) | |
| case val x2832: foo.num = x2831._1 | |
| if x2832.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2833: foo.Bit0 = | |
| x2832.asInstanceOf[foo.Bit0] | |
| case val x2834: foo.Bit0 = | |
| foo.Bit0.unapply(x2833) | |
| case val x2835: foo.num = x2834._1 | |
| if x2835.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2836: foo.One = | |
| x2835.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2836) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(129) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2832.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2808: foo.Bit1 = | |
| x2832.asInstanceOf[foo.Bit1] | |
| case val x2809: foo.Bit1 = | |
| foo.Bit1.unapply(x2808) | |
| case val x2810: foo.num = x2809._1 | |
| if x2810.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2811: foo.One = | |
| x2810.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2811) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(193) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2832.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2786: foo.One = | |
| x2832.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2786) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(65) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2829.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2758: foo.Bit1 = | |
| x2829.asInstanceOf[foo.Bit1] | |
| case val x2759: foo.Bit1 = | |
| foo.Bit1.unapply(x2758) | |
| case val x2760: foo.num = x2759._1 | |
| if x2760.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2761: foo.Bit0 = | |
| x2760.asInstanceOf[foo.Bit0] | |
| case val x2762: foo.Bit0 = | |
| foo.Bit0.unapply(x2761) | |
| case val x2763: foo.num = x2762._1 | |
| if x2763.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2764: foo.One = | |
| x2763.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2764) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(161) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2760.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2736: foo.Bit1 = | |
| x2760.asInstanceOf[foo.Bit1] | |
| case val x2737: foo.Bit1 = | |
| foo.Bit1.unapply(x2736) | |
| case val x2738: foo.num = x2737._1 | |
| if x2738.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2739: foo.One = | |
| x2738.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2739) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(225) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2760.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2714: foo.One = | |
| x2760.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2714) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(97) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2829.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2692: foo.One = | |
| x2829.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2692) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(33) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2826.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2664: foo.Bit1 = | |
| x2826.asInstanceOf[foo.Bit1] | |
| case val x2665: foo.Bit1 = | |
| foo.Bit1.unapply(x2664) | |
| case val x2666: foo.num = x2665._1 | |
| if x2666.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2667: foo.Bit0 = | |
| x2666.asInstanceOf[foo.Bit0] | |
| case val x2668: foo.Bit0 = | |
| foo.Bit0.unapply(x2667) | |
| case val x2669: foo.num = x2668._1 | |
| if x2669.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2670: foo.Bit0 = | |
| x2669.asInstanceOf[foo.Bit0] | |
| case val x2671: foo.Bit0 = | |
| foo.Bit0.unapply(x2670) | |
| case val x2672: foo.num = x2671._1 | |
| if x2672.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2673: foo.One = | |
| x2672.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2673) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(145) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2669.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2645: foo.Bit1 = | |
| x2669.asInstanceOf[foo.Bit1] | |
| case val x2646: foo.Bit1 = | |
| foo.Bit1.unapply(x2645) | |
| case val x2647: foo.num = x2646._1 | |
| if x2647.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2648: foo.One = | |
| x2647.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2648) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(209) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2669.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2623: foo.One = | |
| x2669.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2623) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(81) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2666.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2595: foo.Bit1 = | |
| x2666.asInstanceOf[foo.Bit1] | |
| case val x2596: foo.Bit1 = | |
| foo.Bit1.unapply(x2595) | |
| case val x2597: foo.num = x2596._1 | |
| if x2597.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2598: foo.Bit0 = | |
| x2597.asInstanceOf[foo.Bit0] | |
| case val x2599: foo.Bit0 = | |
| foo.Bit0.unapply(x2598) | |
| case val x2600: foo.num = x2599._1 | |
| if x2600.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2601: foo.One = | |
| x2600.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2601) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(177) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2597.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2573: foo.Bit1 = | |
| x2597.asInstanceOf[foo.Bit1] | |
| case val x2574: foo.Bit1 = | |
| foo.Bit1.unapply(x2573) | |
| case val x2575: foo.num = x2574._1 | |
| if x2575.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2576: foo.One = | |
| x2575.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2576) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(241) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2597.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2551: foo.One = | |
| x2597.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2551) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(113) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2666.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2529: foo.One = | |
| x2666.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2529) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(49) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2826.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2510: foo.One = | |
| x2826.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2510) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(17) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2823.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2482: foo.Bit1 = | |
| x2823.asInstanceOf[foo.Bit1] | |
| case val x2483: foo.Bit1 = foo.Bit1.unapply(x2482) | |
| case val x2484: foo.num = x2483._1 | |
| if x2484.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2485: foo.Bit0 = | |
| x2484.asInstanceOf[foo.Bit0] | |
| case val x2486: foo.Bit0 = | |
| foo.Bit0.unapply(x2485) | |
| case val x2487: foo.num = x2486._1 | |
| if x2487.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2488: foo.Bit0 = | |
| x2487.asInstanceOf[foo.Bit0] | |
| case val x2489: foo.Bit0 = | |
| foo.Bit0.unapply(x2488) | |
| case val x2490: foo.num = x2489._1 | |
| if x2490.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2491: foo.Bit0 = | |
| x2490.asInstanceOf[foo.Bit0] | |
| case val x2492: foo.Bit0 = | |
| foo.Bit0.unapply(x2491) | |
| case val x2493: foo.num = x2492._1 | |
| if x2493.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2494: foo.One = | |
| x2493.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2494) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(137) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2490.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2466: foo.Bit1 = | |
| x2490.asInstanceOf[foo.Bit1] | |
| case val x2467: foo.Bit1 = | |
| foo.Bit1.unapply(x2466) | |
| case val x2468: foo.num = x2467._1 | |
| if x2468.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2469: foo.One = | |
| x2468.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2469) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(201) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2490.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2444: foo.One = | |
| x2490.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2444) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(73) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2487.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2416: foo.Bit1 = | |
| x2487.asInstanceOf[foo.Bit1] | |
| case val x2417: foo.Bit1 = | |
| foo.Bit1.unapply(x2416) | |
| case val x2418: foo.num = x2417._1 | |
| if x2418.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2419: foo.Bit0 = | |
| x2418.asInstanceOf[foo.Bit0] | |
| case val x2420: foo.Bit0 = | |
| foo.Bit0.unapply(x2419) | |
| case val x2421: foo.num = x2420._1 | |
| if x2421.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2422: foo.One = | |
| x2421.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2422) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(169) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2418.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2394: foo.Bit1 = | |
| x2418.asInstanceOf[foo.Bit1] | |
| case val x2395: foo.Bit1 = | |
| foo.Bit1.unapply(x2394) | |
| case val x2396: foo.num = x2395._1 | |
| if x2396.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2397: foo.One = | |
| x2396.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2397) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(233) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2418.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2372: foo.One = | |
| x2418.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2372) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(105) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2487.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2350: foo.One = | |
| x2487.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2350) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(41) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2484.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2322: foo.Bit1 = | |
| x2484.asInstanceOf[foo.Bit1] | |
| case val x2323: foo.Bit1 = | |
| foo.Bit1.unapply(x2322) | |
| case val x2324: foo.num = x2323._1 | |
| if x2324.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2325: foo.Bit0 = | |
| x2324.asInstanceOf[foo.Bit0] | |
| case val x2326: foo.Bit0 = | |
| foo.Bit0.unapply(x2325) | |
| case val x2327: foo.num = x2326._1 | |
| if x2327.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2328: foo.Bit0 = | |
| x2327.asInstanceOf[foo.Bit0] | |
| case val x2329: foo.Bit0 = | |
| foo.Bit0.unapply(x2328) | |
| case val x2330: foo.num = x2329._1 | |
| if x2330.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2331: foo.One = | |
| x2330.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2331) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(153) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2327.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2303: foo.Bit1 = | |
| x2327.asInstanceOf[foo.Bit1] | |
| case val x2304: foo.Bit1 = | |
| foo.Bit1.unapply(x2303) | |
| case val x2305: foo.num = x2304._1 | |
| if x2305.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2306: foo.One = | |
| x2305.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2306) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(217) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2327.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2281: foo.One = | |
| x2327.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2281) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(89) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2324.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2253: foo.Bit1 = | |
| x2324.asInstanceOf[foo.Bit1] | |
| case val x2254: foo.Bit1 = | |
| foo.Bit1.unapply(x2253) | |
| case val x2255: foo.num = x2254._1 | |
| if x2255.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2256: foo.Bit0 = | |
| x2255.asInstanceOf[foo.Bit0] | |
| case val x2257: foo.Bit0 = | |
| foo.Bit0.unapply(x2256) | |
| case val x2258: foo.num = x2257._1 | |
| if x2258.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2259: foo.One = | |
| x2258.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2259) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(185) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2255.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2231: foo.Bit1 = | |
| x2255.asInstanceOf[foo.Bit1] | |
| case val x2232: foo.Bit1 = | |
| foo.Bit1.unapply(x2231) | |
| case val x2233: foo.num = x2232._1 | |
| if x2233.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2234: foo.One = | |
| x2233.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2234) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(249) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2255.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2209: foo.One = | |
| x2255.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2209) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(121) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2324.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2187: foo.One = | |
| x2324.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2187) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(57) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2484.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2168: foo.One = | |
| x2484.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2168) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(25) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2823.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2152: foo.One = | |
| x2823.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2152) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(9) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2820.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2124: foo.Bit1 = | |
| x2820.asInstanceOf[foo.Bit1] | |
| case val x2125: foo.Bit1 = foo.Bit1.unapply(x2124) | |
| case val x2126: foo.num = x2125._1 | |
| if x2126.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2127: foo.Bit0 = | |
| x2126.asInstanceOf[foo.Bit0] | |
| case val x2128: foo.Bit0 = foo.Bit0.unapply(x2127) | |
| case val x2129: foo.num = x2128._1 | |
| if x2129.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2130: foo.Bit0 = | |
| x2129.asInstanceOf[foo.Bit0] | |
| case val x2131: foo.Bit0 = | |
| foo.Bit0.unapply(x2130) | |
| case val x2132: foo.num = x2131._1 | |
| if x2132.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2133: foo.Bit0 = | |
| x2132.asInstanceOf[foo.Bit0] | |
| case val x2134: foo.Bit0 = | |
| foo.Bit0.unapply(x2133) | |
| case val x2135: foo.num = x2134._1 | |
| if x2135.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2136: foo.Bit0 = | |
| x2135.asInstanceOf[foo.Bit0] | |
| case val x2137: foo.Bit0 = | |
| foo.Bit0.unapply(x2136) | |
| case val x2138: foo.num = x2137._1 | |
| if x2138.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2139: foo.One = | |
| x2138.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2139) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(133) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2135.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2111: foo.Bit1 = | |
| x2135.asInstanceOf[foo.Bit1] | |
| case val x2112: foo.Bit1 = | |
| foo.Bit1.unapply(x2111) | |
| case val x2113: foo.num = x2112._1 | |
| if x2113.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2114: foo.One = | |
| x2113.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2114) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(197) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2135.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2089: foo.One = | |
| x2135.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2089) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(69) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2132.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2061: foo.Bit1 = | |
| x2132.asInstanceOf[foo.Bit1] | |
| case val x2062: foo.Bit1 = | |
| foo.Bit1.unapply(x2061) | |
| case val x2063: foo.num = x2062._1 | |
| if x2063.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x2064: foo.Bit0 = | |
| x2063.asInstanceOf[foo.Bit0] | |
| case val x2065: foo.Bit0 = | |
| foo.Bit0.unapply(x2064) | |
| case val x2066: foo.num = x2065._1 | |
| if x2066.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2067: foo.One = | |
| x2066.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2067) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(165) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2063.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x2039: foo.Bit1 = | |
| x2063.asInstanceOf[foo.Bit1] | |
| case val x2040: foo.Bit1 = | |
| foo.Bit1.unapply(x2039) | |
| case val x2041: foo.num = x2040._1 | |
| if x2041.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2042: foo.One = | |
| x2041.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2042) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(229) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2063.$isInstanceOf$[foo.One] then | |
| { | |
| case val x2017: foo.One = | |
| x2063.asInstanceOf[foo.One] | |
| if foo.One.unapply(x2017) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(101) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2132.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1995: foo.One = | |
| x2132.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1995) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(37) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2129.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1967: foo.Bit1 = | |
| x2129.asInstanceOf[foo.Bit1] | |
| case val x1968: foo.Bit1 = | |
| foo.Bit1.unapply(x1967) | |
| case val x1969: foo.num = x1968._1 | |
| if x1969.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1970: foo.Bit0 = | |
| x1969.asInstanceOf[foo.Bit0] | |
| case val x1971: foo.Bit0 = | |
| foo.Bit0.unapply(x1970) | |
| case val x1972: foo.num = x1971._1 | |
| if x1972.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1973: foo.Bit0 = | |
| x1972.asInstanceOf[foo.Bit0] | |
| case val x1974: foo.Bit0 = | |
| foo.Bit0.unapply(x1973) | |
| case val x1975: foo.num = x1974._1 | |
| if x1975.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1976: foo.One = | |
| x1975.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1976) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(149) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1972.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1948: foo.Bit1 = | |
| x1972.asInstanceOf[foo.Bit1] | |
| case val x1949: foo.Bit1 = | |
| foo.Bit1.unapply(x1948) | |
| case val x1950: foo.num = x1949._1 | |
| if x1950.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1951: foo.One = | |
| x1950.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1951) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(213) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1972.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1926: foo.One = | |
| x1972.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1926) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(85) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1969.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1898: foo.Bit1 = | |
| x1969.asInstanceOf[foo.Bit1] | |
| case val x1899: foo.Bit1 = | |
| foo.Bit1.unapply(x1898) | |
| case val x1900: foo.num = x1899._1 | |
| if x1900.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1901: foo.Bit0 = | |
| x1900.asInstanceOf[foo.Bit0] | |
| case val x1902: foo.Bit0 = | |
| foo.Bit0.unapply(x1901) | |
| case val x1903: foo.num = x1902._1 | |
| if x1903.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1904: foo.One = | |
| x1903.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1904) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(181) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1900.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1876: foo.Bit1 = | |
| x1900.asInstanceOf[foo.Bit1] | |
| case val x1877: foo.Bit1 = | |
| foo.Bit1.unapply(x1876) | |
| case val x1878: foo.num = x1877._1 | |
| if x1878.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1879: foo.One = | |
| x1878.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1879) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(245) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1900.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1854: foo.One = | |
| x1900.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1854) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(117) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1969.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1832: foo.One = | |
| x1969.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1832) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(53) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2129.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1813: foo.One = | |
| x2129.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1813) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(21) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2126.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1785: foo.Bit1 = | |
| x2126.asInstanceOf[foo.Bit1] | |
| case val x1786: foo.Bit1 = foo.Bit1.unapply(x1785) | |
| case val x1787: foo.num = x1786._1 | |
| if x1787.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1788: foo.Bit0 = | |
| x1787.asInstanceOf[foo.Bit0] | |
| case val x1789: foo.Bit0 = | |
| foo.Bit0.unapply(x1788) | |
| case val x1790: foo.num = x1789._1 | |
| if x1790.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1791: foo.Bit0 = | |
| x1790.asInstanceOf[foo.Bit0] | |
| case val x1792: foo.Bit0 = | |
| foo.Bit0.unapply(x1791) | |
| case val x1793: foo.num = x1792._1 | |
| if x1793.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1794: foo.Bit0 = | |
| x1793.asInstanceOf[foo.Bit0] | |
| case val x1795: foo.Bit0 = | |
| foo.Bit0.unapply(x1794) | |
| case val x1796: foo.num = x1795._1 | |
| if x1796.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1797: foo.One = | |
| x1796.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1797) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(141) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1793.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1769: foo.Bit1 = | |
| x1793.asInstanceOf[foo.Bit1] | |
| case val x1770: foo.Bit1 = | |
| foo.Bit1.unapply(x1769) | |
| case val x1771: foo.num = x1770._1 | |
| if x1771.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1772: foo.One = | |
| x1771.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1772) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(205) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1793.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1747: foo.One = | |
| x1793.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1747) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(77) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1790.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1719: foo.Bit1 = | |
| x1790.asInstanceOf[foo.Bit1] | |
| case val x1720: foo.Bit1 = | |
| foo.Bit1.unapply(x1719) | |
| case val x1721: foo.num = x1720._1 | |
| if x1721.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1722: foo.Bit0 = | |
| x1721.asInstanceOf[foo.Bit0] | |
| case val x1723: foo.Bit0 = | |
| foo.Bit0.unapply(x1722) | |
| case val x1724: foo.num = x1723._1 | |
| if x1724.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1725: foo.One = | |
| x1724.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1725) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(173) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1721.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1697: foo.Bit1 = | |
| x1721.asInstanceOf[foo.Bit1] | |
| case val x1698: foo.Bit1 = | |
| foo.Bit1.unapply(x1697) | |
| case val x1699: foo.num = x1698._1 | |
| if x1699.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1700: foo.One = | |
| x1699.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1700) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(237) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1721.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1675: foo.One = | |
| x1721.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1675) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(109) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1790.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1653: foo.One = | |
| x1790.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1653) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(45) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1787.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1625: foo.Bit1 = | |
| x1787.asInstanceOf[foo.Bit1] | |
| case val x1626: foo.Bit1 = | |
| foo.Bit1.unapply(x1625) | |
| case val x1627: foo.num = x1626._1 | |
| if x1627.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1628: foo.Bit0 = | |
| x1627.asInstanceOf[foo.Bit0] | |
| case val x1629: foo.Bit0 = | |
| foo.Bit0.unapply(x1628) | |
| case val x1630: foo.num = x1629._1 | |
| if x1630.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1631: foo.Bit0 = | |
| x1630.asInstanceOf[foo.Bit0] | |
| case val x1632: foo.Bit0 = | |
| foo.Bit0.unapply(x1631) | |
| case val x1633: foo.num = x1632._1 | |
| if x1633.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1634: foo.One = | |
| x1633.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1634) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(157) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1630.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1606: foo.Bit1 = | |
| x1630.asInstanceOf[foo.Bit1] | |
| case val x1607: foo.Bit1 = | |
| foo.Bit1.unapply(x1606) | |
| case val x1608: foo.num = x1607._1 | |
| if x1608.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1609: foo.One = | |
| x1608.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1609) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(221) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1630.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1584: foo.One = | |
| x1630.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1584) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(93) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1627.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1556: foo.Bit1 = | |
| x1627.asInstanceOf[foo.Bit1] | |
| case val x1557: foo.Bit1 = | |
| foo.Bit1.unapply(x1556) | |
| case val x1558: foo.num = x1557._1 | |
| if x1558.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1559: foo.Bit0 = | |
| x1558.asInstanceOf[foo.Bit0] | |
| case val x1560: foo.Bit0 = | |
| foo.Bit0.unapply(x1559) | |
| case val x1561: foo.num = x1560._1 | |
| if x1561.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1562: foo.One = | |
| x1561.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1562) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(189) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1558.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1534: foo.Bit1 = | |
| x1558.asInstanceOf[foo.Bit1] | |
| case val x1535: foo.Bit1 = | |
| foo.Bit1.unapply(x1534) | |
| case val x1536: foo.num = x1535._1 | |
| if x1536.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1537: foo.One = | |
| x1536.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1537) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(253) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1558.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1512: foo.One = | |
| x1558.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1512) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(125) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1627.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1490: foo.One = | |
| x1627.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1490) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(61) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1787.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1471: foo.One = | |
| x1787.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1471) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(29) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2126.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1455: foo.One = | |
| x2126.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1455) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(13) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2820.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1442: foo.One = x2820.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1442) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(5) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2817.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1414: foo.Bit1 = x2817.asInstanceOf[foo.Bit1] | |
| case val x1415: foo.Bit1 = foo.Bit1.unapply(x1414) | |
| case val x1416: foo.num = x1415._1 | |
| if x1416.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1417: foo.Bit0 = | |
| x1416.asInstanceOf[foo.Bit0] | |
| case val x1418: foo.Bit0 = foo.Bit0.unapply(x1417) | |
| case val x1419: foo.num = x1418._1 | |
| if x1419.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1420: foo.Bit0 = | |
| x1419.asInstanceOf[foo.Bit0] | |
| case val x1421: foo.Bit0 = foo.Bit0.unapply(x1420) | |
| case val x1422: foo.num = x1421._1 | |
| if x1422.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1423: foo.Bit0 = | |
| x1422.asInstanceOf[foo.Bit0] | |
| case val x1424: foo.Bit0 = | |
| foo.Bit0.unapply(x1423) | |
| case val x1425: foo.num = x1424._1 | |
| if x1425.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1426: foo.Bit0 = | |
| x1425.asInstanceOf[foo.Bit0] | |
| case val x1427: foo.Bit0 = | |
| foo.Bit0.unapply(x1426) | |
| case val x1428: foo.num = x1427._1 | |
| if x1428.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1429: foo.Bit0 = | |
| x1428.asInstanceOf[foo.Bit0] | |
| case val x1430: foo.Bit0 = | |
| foo.Bit0.unapply(x1429) | |
| case val x1431: foo.num = x1430._1 | |
| if x1431.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1432: foo.One = | |
| x1431.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1432) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(131) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1428.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1404: foo.Bit1 = | |
| x1428.asInstanceOf[foo.Bit1] | |
| case val x1405: foo.Bit1 = | |
| foo.Bit1.unapply(x1404) | |
| case val x1406: foo.num = x1405._1 | |
| if x1406.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1407: foo.One = | |
| x1406.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1407) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(195) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1428.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1382: foo.One = | |
| x1428.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1382) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(67) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1425.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1354: foo.Bit1 = | |
| x1425.asInstanceOf[foo.Bit1] | |
| case val x1355: foo.Bit1 = | |
| foo.Bit1.unapply(x1354) | |
| case val x1356: foo.num = x1355._1 | |
| if x1356.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1357: foo.Bit0 = | |
| x1356.asInstanceOf[foo.Bit0] | |
| case val x1358: foo.Bit0 = | |
| foo.Bit0.unapply(x1357) | |
| case val x1359: foo.num = x1358._1 | |
| if x1359.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1360: foo.One = | |
| x1359.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1360) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(163) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1356.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1332: foo.Bit1 = | |
| x1356.asInstanceOf[foo.Bit1] | |
| case val x1333: foo.Bit1 = | |
| foo.Bit1.unapply(x1332) | |
| case val x1334: foo.num = x1333._1 | |
| if x1334.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1335: foo.One = | |
| x1334.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1335) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(227) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1356.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1310: foo.One = | |
| x1356.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1310) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(99) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1425.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1288: foo.One = | |
| x1425.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1288) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(35) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1422.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1260: foo.Bit1 = | |
| x1422.asInstanceOf[foo.Bit1] | |
| case val x1261: foo.Bit1 = | |
| foo.Bit1.unapply(x1260) | |
| case val x1262: foo.num = x1261._1 | |
| if x1262.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1263: foo.Bit0 = | |
| x1262.asInstanceOf[foo.Bit0] | |
| case val x1264: foo.Bit0 = | |
| foo.Bit0.unapply(x1263) | |
| case val x1265: foo.num = x1264._1 | |
| if x1265.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1266: foo.Bit0 = | |
| x1265.asInstanceOf[foo.Bit0] | |
| case val x1267: foo.Bit0 = | |
| foo.Bit0.unapply(x1266) | |
| case val x1268: foo.num = x1267._1 | |
| if x1268.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1269: foo.One = | |
| x1268.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1269) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(147) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1265.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1241: foo.Bit1 = | |
| x1265.asInstanceOf[foo.Bit1] | |
| case val x1242: foo.Bit1 = | |
| foo.Bit1.unapply(x1241) | |
| case val x1243: foo.num = x1242._1 | |
| if x1243.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1244: foo.One = | |
| x1243.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1244) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(211) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1265.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1219: foo.One = | |
| x1265.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1219) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(83) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1262.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1191: foo.Bit1 = | |
| x1262.asInstanceOf[foo.Bit1] | |
| case val x1192: foo.Bit1 = | |
| foo.Bit1.unapply(x1191) | |
| case val x1193: foo.num = x1192._1 | |
| if x1193.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1194: foo.Bit0 = | |
| x1193.asInstanceOf[foo.Bit0] | |
| case val x1195: foo.Bit0 = | |
| foo.Bit0.unapply(x1194) | |
| case val x1196: foo.num = x1195._1 | |
| if x1196.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1197: foo.One = | |
| x1196.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1197) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(179) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1193.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1169: foo.Bit1 = | |
| x1193.asInstanceOf[foo.Bit1] | |
| case val x1170: foo.Bit1 = | |
| foo.Bit1.unapply(x1169) | |
| case val x1171: foo.num = x1170._1 | |
| if x1171.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1172: foo.One = | |
| x1171.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1172) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(243) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1193.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1147: foo.One = | |
| x1193.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1147) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(115) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1262.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1125: foo.One = | |
| x1262.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1125) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(51) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1422.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1106: foo.One = | |
| x1422.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1106) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(19) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1419.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1078: foo.Bit1 = | |
| x1419.asInstanceOf[foo.Bit1] | |
| case val x1079: foo.Bit1 = foo.Bit1.unapply(x1078) | |
| case val x1080: foo.num = x1079._1 | |
| if x1080.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1081: foo.Bit0 = | |
| x1080.asInstanceOf[foo.Bit0] | |
| case val x1082: foo.Bit0 = | |
| foo.Bit0.unapply(x1081) | |
| case val x1083: foo.num = x1082._1 | |
| if x1083.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1084: foo.Bit0 = | |
| x1083.asInstanceOf[foo.Bit0] | |
| case val x1085: foo.Bit0 = | |
| foo.Bit0.unapply(x1084) | |
| case val x1086: foo.num = x1085._1 | |
| if x1086.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1087: foo.Bit0 = | |
| x1086.asInstanceOf[foo.Bit0] | |
| case val x1088: foo.Bit0 = | |
| foo.Bit0.unapply(x1087) | |
| case val x1089: foo.num = x1088._1 | |
| if x1089.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1090: foo.One = | |
| x1089.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1090) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(139) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1086.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1062: foo.Bit1 = | |
| x1086.asInstanceOf[foo.Bit1] | |
| case val x1063: foo.Bit1 = | |
| foo.Bit1.unapply(x1062) | |
| case val x1064: foo.num = x1063._1 | |
| if x1064.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1065: foo.One = | |
| x1064.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1065) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(203) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1086.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1040: foo.One = | |
| x1086.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1040) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(75) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1083.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x1012: foo.Bit1 = | |
| x1083.asInstanceOf[foo.Bit1] | |
| case val x1013: foo.Bit1 = | |
| foo.Bit1.unapply(x1012) | |
| case val x1014: foo.num = x1013._1 | |
| if x1014.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x1015: foo.Bit0 = | |
| x1014.asInstanceOf[foo.Bit0] | |
| case val x1016: foo.Bit0 = | |
| foo.Bit0.unapply(x1015) | |
| case val x1017: foo.num = x1016._1 | |
| if x1017.$isInstanceOf$[foo.One] then | |
| { | |
| case val x1018: foo.One = | |
| x1017.asInstanceOf[foo.One] | |
| if foo.One.unapply(x1018) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(171) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1014.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x990: foo.Bit1 = | |
| x1014.asInstanceOf[foo.Bit1] | |
| case val x991: foo.Bit1 = | |
| foo.Bit1.unapply(x990) | |
| case val x992: foo.num = x991._1 | |
| if x992.$isInstanceOf$[foo.One] then | |
| { | |
| case val x993: foo.One = | |
| x992.asInstanceOf[foo.One] | |
| if foo.One.unapply(x993) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(235) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1014.$isInstanceOf$[foo.One] then | |
| { | |
| case val x968: foo.One = | |
| x1014.asInstanceOf[foo.One] | |
| if foo.One.unapply(x968) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(107) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1083.$isInstanceOf$[foo.One] then | |
| { | |
| case val x946: foo.One = | |
| x1083.asInstanceOf[foo.One] | |
| if foo.One.unapply(x946) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(43) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1080.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x918: foo.Bit1 = | |
| x1080.asInstanceOf[foo.Bit1] | |
| case val x919: foo.Bit1 = | |
| foo.Bit1.unapply(x918) | |
| case val x920: foo.num = x919._1 | |
| if x920.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x921: foo.Bit0 = | |
| x920.asInstanceOf[foo.Bit0] | |
| case val x922: foo.Bit0 = | |
| foo.Bit0.unapply(x921) | |
| case val x923: foo.num = x922._1 | |
| if x923.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x924: foo.Bit0 = | |
| x923.asInstanceOf[foo.Bit0] | |
| case val x925: foo.Bit0 = | |
| foo.Bit0.unapply(x924) | |
| case val x926: foo.num = x925._1 | |
| if x926.$isInstanceOf$[foo.One] then | |
| { | |
| case val x927: foo.One = | |
| x926.asInstanceOf[foo.One] | |
| if foo.One.unapply(x927) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(155) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x923.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x899: foo.Bit1 = | |
| x923.asInstanceOf[foo.Bit1] | |
| case val x900: foo.Bit1 = | |
| foo.Bit1.unapply(x899) | |
| case val x901: foo.num = x900._1 | |
| if x901.$isInstanceOf$[foo.One] then | |
| { | |
| case val x902: foo.One = | |
| x901.asInstanceOf[foo.One] | |
| if foo.One.unapply(x902) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(219) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x923.$isInstanceOf$[foo.One] then | |
| { | |
| case val x877: foo.One = | |
| x923.asInstanceOf[foo.One] | |
| if foo.One.unapply(x877) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(91) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x920.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x849: foo.Bit1 = | |
| x920.asInstanceOf[foo.Bit1] | |
| case val x850: foo.Bit1 = | |
| foo.Bit1.unapply(x849) | |
| case val x851: foo.num = x850._1 | |
| if x851.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x852: foo.Bit0 = | |
| x851.asInstanceOf[foo.Bit0] | |
| case val x853: foo.Bit0 = | |
| foo.Bit0.unapply(x852) | |
| case val x854: foo.num = x853._1 | |
| if x854.$isInstanceOf$[foo.One] then | |
| { | |
| case val x855: foo.One = | |
| x854.asInstanceOf[foo.One] | |
| if foo.One.unapply(x855) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(187) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x851.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x827: foo.Bit1 = | |
| x851.asInstanceOf[foo.Bit1] | |
| case val x828: foo.Bit1 = | |
| foo.Bit1.unapply(x827) | |
| case val x829: foo.num = x828._1 | |
| if x829.$isInstanceOf$[foo.One] then | |
| { | |
| case val x830: foo.One = | |
| x829.asInstanceOf[foo.One] | |
| if foo.One.unapply(x830) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(251) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x851.$isInstanceOf$[foo.One] then | |
| { | |
| case val x805: foo.One = | |
| x851.asInstanceOf[foo.One] | |
| if foo.One.unapply(x805) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(123) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x920.$isInstanceOf$[foo.One] then | |
| { | |
| case val x783: foo.One = | |
| x920.asInstanceOf[foo.One] | |
| if foo.One.unapply(x783) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(59) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1080.$isInstanceOf$[foo.One] then | |
| { | |
| case val x764: foo.One = | |
| x1080.asInstanceOf[foo.One] | |
| if foo.One.unapply(x764) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(27) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1419.$isInstanceOf$[foo.One] then | |
| { | |
| case val x748: foo.One = | |
| x1419.asInstanceOf[foo.One] | |
| if foo.One.unapply(x748) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(11) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1416.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x720: foo.Bit1 = x1416.asInstanceOf[foo.Bit1] | |
| case val x721: foo.Bit1 = foo.Bit1.unapply(x720) | |
| case val x722: foo.num = x721._1 | |
| if x722.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x723: foo.Bit0 = | |
| x722.asInstanceOf[foo.Bit0] | |
| case val x724: foo.Bit0 = foo.Bit0.unapply(x723) | |
| case val x725: foo.num = x724._1 | |
| if x725.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x726: foo.Bit0 = | |
| x725.asInstanceOf[foo.Bit0] | |
| case val x727: foo.Bit0 = | |
| foo.Bit0.unapply(x726) | |
| case val x728: foo.num = x727._1 | |
| if x728.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x729: foo.Bit0 = | |
| x728.asInstanceOf[foo.Bit0] | |
| case val x730: foo.Bit0 = | |
| foo.Bit0.unapply(x729) | |
| case val x731: foo.num = x730._1 | |
| if x731.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x732: foo.Bit0 = | |
| x731.asInstanceOf[foo.Bit0] | |
| case val x733: foo.Bit0 = | |
| foo.Bit0.unapply(x732) | |
| case val x734: foo.num = x733._1 | |
| if x734.$isInstanceOf$[foo.One] then | |
| { | |
| case val x735: foo.One = | |
| x734.asInstanceOf[foo.One] | |
| if foo.One.unapply(x735) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(135) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x731.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x707: foo.Bit1 = | |
| x731.asInstanceOf[foo.Bit1] | |
| case val x708: foo.Bit1 = | |
| foo.Bit1.unapply(x707) | |
| case val x709: foo.num = x708._1 | |
| if x709.$isInstanceOf$[foo.One] then | |
| { | |
| case val x710: foo.One = | |
| x709.asInstanceOf[foo.One] | |
| if foo.One.unapply(x710) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(199) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x731.$isInstanceOf$[foo.One] then | |
| { | |
| case val x685: foo.One = | |
| x731.asInstanceOf[foo.One] | |
| if foo.One.unapply(x685) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(71) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x728.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x657: foo.Bit1 = | |
| x728.asInstanceOf[foo.Bit1] | |
| case val x658: foo.Bit1 = | |
| foo.Bit1.unapply(x657) | |
| case val x659: foo.num = x658._1 | |
| if x659.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x660: foo.Bit0 = | |
| x659.asInstanceOf[foo.Bit0] | |
| case val x661: foo.Bit0 = | |
| foo.Bit0.unapply(x660) | |
| case val x662: foo.num = x661._1 | |
| if x662.$isInstanceOf$[foo.One] then | |
| { | |
| case val x663: foo.One = | |
| x662.asInstanceOf[foo.One] | |
| if foo.One.unapply(x663) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(167) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x659.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x635: foo.Bit1 = | |
| x659.asInstanceOf[foo.Bit1] | |
| case val x636: foo.Bit1 = | |
| foo.Bit1.unapply(x635) | |
| case val x637: foo.num = x636._1 | |
| if x637.$isInstanceOf$[foo.One] then | |
| { | |
| case val x638: foo.One = | |
| x637.asInstanceOf[foo.One] | |
| if foo.One.unapply(x638) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(231) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x659.$isInstanceOf$[foo.One] then | |
| { | |
| case val x613: foo.One = | |
| x659.asInstanceOf[foo.One] | |
| if foo.One.unapply(x613) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(103) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x728.$isInstanceOf$[foo.One] then | |
| { | |
| case val x591: foo.One = | |
| x728.asInstanceOf[foo.One] | |
| if foo.One.unapply(x591) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(39) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x725.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x563: foo.Bit1 = | |
| x725.asInstanceOf[foo.Bit1] | |
| case val x564: foo.Bit1 = | |
| foo.Bit1.unapply(x563) | |
| case val x565: foo.num = x564._1 | |
| if x565.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x566: foo.Bit0 = | |
| x565.asInstanceOf[foo.Bit0] | |
| case val x567: foo.Bit0 = | |
| foo.Bit0.unapply(x566) | |
| case val x568: foo.num = x567._1 | |
| if x568.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x569: foo.Bit0 = | |
| x568.asInstanceOf[foo.Bit0] | |
| case val x570: foo.Bit0 = | |
| foo.Bit0.unapply(x569) | |
| case val x571: foo.num = x570._1 | |
| if x571.$isInstanceOf$[foo.One] then | |
| { | |
| case val x572: foo.One = | |
| x571.asInstanceOf[foo.One] | |
| if foo.One.unapply(x572) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(151) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x568.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x544: foo.Bit1 = | |
| x568.asInstanceOf[foo.Bit1] | |
| case val x545: foo.Bit1 = | |
| foo.Bit1.unapply(x544) | |
| case val x546: foo.num = x545._1 | |
| if x546.$isInstanceOf$[foo.One] then | |
| { | |
| case val x547: foo.One = | |
| x546.asInstanceOf[foo.One] | |
| if foo.One.unapply(x547) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(215) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x568.$isInstanceOf$[foo.One] then | |
| { | |
| case val x522: foo.One = | |
| x568.asInstanceOf[foo.One] | |
| if foo.One.unapply(x522) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(87) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x565.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x494: foo.Bit1 = | |
| x565.asInstanceOf[foo.Bit1] | |
| case val x495: foo.Bit1 = | |
| foo.Bit1.unapply(x494) | |
| case val x496: foo.num = x495._1 | |
| if x496.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x497: foo.Bit0 = | |
| x496.asInstanceOf[foo.Bit0] | |
| case val x498: foo.Bit0 = | |
| foo.Bit0.unapply(x497) | |
| case val x499: foo.num = x498._1 | |
| if x499.$isInstanceOf$[foo.One] then | |
| { | |
| case val x500: foo.One = | |
| x499.asInstanceOf[foo.One] | |
| if foo.One.unapply(x500) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(183) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x496.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x472: foo.Bit1 = | |
| x496.asInstanceOf[foo.Bit1] | |
| case val x473: foo.Bit1 = | |
| foo.Bit1.unapply(x472) | |
| case val x474: foo.num = x473._1 | |
| if x474.$isInstanceOf$[foo.One] then | |
| { | |
| case val x475: foo.One = | |
| x474.asInstanceOf[foo.One] | |
| if foo.One.unapply(x475) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(247) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x496.$isInstanceOf$[foo.One] then | |
| { | |
| case val x450: foo.One = | |
| x496.asInstanceOf[foo.One] | |
| if foo.One.unapply(x450) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(119) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x565.$isInstanceOf$[foo.One] then | |
| { | |
| case val x428: foo.One = | |
| x565.asInstanceOf[foo.One] | |
| if foo.One.unapply(x428) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(55) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x725.$isInstanceOf$[foo.One] then | |
| { | |
| case val x409: foo.One = | |
| x725.asInstanceOf[foo.One] | |
| if foo.One.unapply(x409) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(23) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x722.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x381: foo.Bit1 = | |
| x722.asInstanceOf[foo.Bit1] | |
| case val x382: foo.Bit1 = foo.Bit1.unapply(x381) | |
| case val x383: foo.num = x382._1 | |
| if x383.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x384: foo.Bit0 = | |
| x383.asInstanceOf[foo.Bit0] | |
| case val x385: foo.Bit0 = | |
| foo.Bit0.unapply(x384) | |
| case val x386: foo.num = x385._1 | |
| if x386.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x387: foo.Bit0 = | |
| x386.asInstanceOf[foo.Bit0] | |
| case val x388: foo.Bit0 = | |
| foo.Bit0.unapply(x387) | |
| case val x389: foo.num = x388._1 | |
| if x389.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x390: foo.Bit0 = | |
| x389.asInstanceOf[foo.Bit0] | |
| case val x391: foo.Bit0 = | |
| foo.Bit0.unapply(x390) | |
| case val x392: foo.num = x391._1 | |
| if x392.$isInstanceOf$[foo.One] then | |
| { | |
| case val x393: foo.One = | |
| x392.asInstanceOf[foo.One] | |
| if foo.One.unapply(x393) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(143) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x389.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x365: foo.Bit1 = | |
| x389.asInstanceOf[foo.Bit1] | |
| case val x366: foo.Bit1 = | |
| foo.Bit1.unapply(x365) | |
| case val x367: foo.num = x366._1 | |
| if x367.$isInstanceOf$[foo.One] then | |
| { | |
| case val x368: foo.One = | |
| x367.asInstanceOf[foo.One] | |
| if foo.One.unapply(x368) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(207) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x389.$isInstanceOf$[foo.One] then | |
| { | |
| case val x343: foo.One = | |
| x389.asInstanceOf[foo.One] | |
| if foo.One.unapply(x343) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(79) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x386.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x315: foo.Bit1 = | |
| x386.asInstanceOf[foo.Bit1] | |
| case val x316: foo.Bit1 = | |
| foo.Bit1.unapply(x315) | |
| case val x317: foo.num = x316._1 | |
| if x317.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x318: foo.Bit0 = | |
| x317.asInstanceOf[foo.Bit0] | |
| case val x319: foo.Bit0 = | |
| foo.Bit0.unapply(x318) | |
| case val x320: foo.num = x319._1 | |
| if x320.$isInstanceOf$[foo.One] then | |
| { | |
| case val x321: foo.One = | |
| x320.asInstanceOf[foo.One] | |
| if foo.One.unapply(x321) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(175) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x317.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x293: foo.Bit1 = | |
| x317.asInstanceOf[foo.Bit1] | |
| case val x294: foo.Bit1 = | |
| foo.Bit1.unapply(x293) | |
| case val x295: foo.num = x294._1 | |
| if x295.$isInstanceOf$[foo.One] then | |
| { | |
| case val x296: foo.One = | |
| x295.asInstanceOf[foo.One] | |
| if foo.One.unapply(x296) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(239) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x317.$isInstanceOf$[foo.One] then | |
| { | |
| case val x271: foo.One = | |
| x317.asInstanceOf[foo.One] | |
| if foo.One.unapply(x271) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(111) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x386.$isInstanceOf$[foo.One] then | |
| { | |
| case val x249: foo.One = | |
| x386.asInstanceOf[foo.One] | |
| if foo.One.unapply(x249) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(47) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x383.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x221: foo.Bit1 = | |
| x383.asInstanceOf[foo.Bit1] | |
| case val x222: foo.Bit1 = | |
| foo.Bit1.unapply(x221) | |
| case val x223: foo.num = x222._1 | |
| if x223.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x224: foo.Bit0 = | |
| x223.asInstanceOf[foo.Bit0] | |
| case val x225: foo.Bit0 = | |
| foo.Bit0.unapply(x224) | |
| case val x226: foo.num = x225._1 | |
| if x226.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x227: foo.Bit0 = | |
| x226.asInstanceOf[foo.Bit0] | |
| case val x228: foo.Bit0 = | |
| foo.Bit0.unapply(x227) | |
| case val x229: foo.num = x228._1 | |
| if x229.$isInstanceOf$[foo.One] then | |
| { | |
| case val x230: foo.One = | |
| x229.asInstanceOf[foo.One] | |
| if foo.One.unapply(x230) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(159) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x226.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x202: foo.Bit1 = | |
| x226.asInstanceOf[foo.Bit1] | |
| case val x203: foo.Bit1 = | |
| foo.Bit1.unapply(x202) | |
| case val x204: foo.num = x203._1 | |
| if x204.$isInstanceOf$[foo.One] then | |
| { | |
| case val x205: foo.One = | |
| x204.asInstanceOf[foo.One] | |
| if foo.One.unapply(x205) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(223) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x226.$isInstanceOf$[foo.One] then | |
| { | |
| case val x180: foo.One = | |
| x226.asInstanceOf[foo.One] | |
| if foo.One.unapply(x180) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(95) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x223.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x152: foo.Bit1 = | |
| x223.asInstanceOf[foo.Bit1] | |
| case val x153: foo.Bit1 = | |
| foo.Bit1.unapply(x152) | |
| case val x154: foo.num = x153._1 | |
| if x154.$isInstanceOf$[foo.Bit0] then | |
| { | |
| case val x155: foo.Bit0 = | |
| x154.asInstanceOf[foo.Bit0] | |
| case val x156: foo.Bit0 = | |
| foo.Bit0.unapply(x155) | |
| case val x157: foo.num = x156._1 | |
| if x157.$isInstanceOf$[foo.One] then | |
| { | |
| case val x158: foo.One = | |
| x157.asInstanceOf[foo.One] | |
| if foo.One.unapply(x158) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(191) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x154.$isInstanceOf$[foo.Bit1] then | |
| { | |
| case val x130: foo.Bit1 = | |
| x154.asInstanceOf[foo.Bit1] | |
| case val x131: foo.Bit1 = | |
| foo.Bit1.unapply(x130) | |
| case val x132: foo.num = x131._1 | |
| if x132.$isInstanceOf$[foo.One] then | |
| { | |
| case val x133: foo.One = | |
| x132.asInstanceOf[foo.One] | |
| if foo.One.unapply(x133) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(255) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x154.$isInstanceOf$[foo.One] then | |
| { | |
| case val x108: foo.One = | |
| x154.asInstanceOf[foo.One] | |
| if foo.One.unapply(x108) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(127) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x223.$isInstanceOf$[foo.One] then | |
| { | |
| case val x86: foo.One = | |
| x223.asInstanceOf[foo.One] | |
| if foo.One.unapply(x86) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(63) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x383.$isInstanceOf$[foo.One] then | |
| { | |
| case val x67: foo.One = | |
| x383.asInstanceOf[foo.One] | |
| if foo.One.unapply(x67) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(31) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x722.$isInstanceOf$[foo.One] then | |
| { | |
| case val x51: foo.One = x722.asInstanceOf[foo.One] | |
| if foo.One.unapply(x51) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(15) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x1416.$isInstanceOf$[foo.One] then | |
| { | |
| case val x38: foo.One = x1416.asInstanceOf[foo.One] | |
| if foo.One.unapply(x38) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(7) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x2817.$isInstanceOf$[foo.One] then | |
| { | |
| case val x28: foo.One = x2817.asInstanceOf[foo.One] | |
| if foo.One.unapply(x28) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(3) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x5629.$isInstanceOf$[foo.One] then | |
| { | |
| case val x21: foo.One = x5629.asInstanceOf[foo.One] | |
| if foo.One.unapply(x21) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(1) | |
| } | |
| else () | |
| } | |
| else () | |
| } | |
| else () | |
| if x16.$isInstanceOf$[foo.zero_char] then | |
| { | |
| case val x17: foo.zero_char = x16.asInstanceOf[foo.zero_char] | |
| if foo.zero_char.unapply(x17) then | |
| return[matchResult11] | |
| { | |
| BigInt.apply(0) | |
| } | |
| else () | |
| } | |
| else () | |
| return[matchResult11] throw new MatchError(x16) | |
| } | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment