From b403461c48b98b00c9c44023f348a88a16e50a16 Mon Sep 17 00:00:00 2001
From: Martijn Hoekstra <martijn.hoekstra@cargoxs.com>
Date: Sat, 23 May 2020 16:07:16 +0200
Subject: [PATCH 1/4] fix back-quoted constructor params with identical
 prefixes

---
 .../tools/nsc/transform/Constructors.scala    | 12 ++---
 .../nsc/typechecker/SyntheticMethods.scala    |  2 +-
 .../scala/reflect/internal/Symbols.scala      | 16 +++++--
 test/files/run/t8831.check                    |  1 +
 test/files/run/t8831.scala                    | 47 +++++++++++++++++++
 5 files changed, 66 insertions(+), 12 deletions(-)
 create mode 100644 test/files/run/t8831.check
 create mode 100644 test/files/run/t8831.scala

diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index 8c3f9e28dd3e..5cb6955a0bc5 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -478,14 +478,12 @@ abstract class Constructors extends Statics with Transform with TypingTransforme
 
     // The constructor parameter with given name. This means the parameter
     // has given name, or starts with given name, and continues with a `$` afterwards.
-    def parameterNamed(name: Name): Symbol = {
-      def matchesName(param: Symbol) = param.name == name || param.name.startsWith(s"${name}${nme.NAME_JOIN_STRING}")
-
-      primaryConstrParams filter matchesName match {
-        case Nil    => abort(s"$name not in $primaryConstrParams")
-        case p :: _ => p
+    def parameterNamed(name: Name): Symbol =
+      primaryConstrParams.filter(_.name.decodedName == name.decodedName) match {
+        case List(p) => p
+        case Nil     => abort(s"$name not in $primaryConstrParams")
+        case ps      => abort(s"$name matches multiple constructor paramters $ps")
       }
-    }
 
     // A transformer for expressions that go into the constructor
     object intoConstructor extends Transformer {
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 2e615fe77432..c24020853fdf 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -122,7 +122,7 @@ trait SyntheticMethods extends ast.TreeDSL {
       )
     }
 
-    def perElementMethod(name: Name, returnType: Type)(caseFn: Symbol => Tree): Tree =
+    def perElementMethod(name: Name, returnType: Type)(caseFn: Symbol => Tree): Tree = 
       createSwitchMethod(name, accessors.indices, returnType)(idx => caseFn(accessors(idx)))
 
     def productElementNameMethod = {
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 1779c8523f65..2c7a9744bdfe 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -2111,18 +2111,26 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       // handling of non-public parameters seems to change the order (see scala/bug#7035.)
       //
       // Luckily, the constrParamAccessors are still sorted properly, so sort the field-accessors using them
-      // (need to undo name-mangling, including the sneaky trailing whitespace)
+      // (need to undo name-mangling, including the sneaky trailing whitespace, and match longest first)
       //
       // The slightly more principled approach of using the paramss of the
       // primary constructor leads to cycles in, for example, pos/t5084.scala.
       val primaryNames = constrParamAccessors map (_.name.dropLocal)
       def nameStartsWithOrigDollar(name: Name, prefix: Name) =
         name.startsWith(prefix) && name.length > prefix.length + 1 && name.charAt(prefix.length) == '$'
-      caseFieldAccessorsUnsorted.sortBy { acc =>
-        primaryNames indexWhere { orig =>
-          (acc.name == orig) || nameStartsWithOrigDollar(acc.name, orig)
+
+      def rec(remaningAccessors: List[Symbol], foundAccessors: List[(Symbol, Int)], remainingNames: List[(Name, Int)]): List[Symbol] = {
+        remaningAccessors match {
+          case Nil => foundAccessors.sortBy(_._2).map(_._1)
+          case acc :: tail => {
+            val i = remainingNames.collectFirst { case (name, i) if acc.name == name || nameStartsWithOrigDollar(acc.name, name) => i}
+            rec(tail, (acc, i.get) :: foundAccessors, remainingNames.filterNot { case (_, ii) => Some(ii) == i} )
+          }
         }
       }
+
+      rec(caseFieldAccessorsUnsorted.sortBy(s => -s.name.length), Nil, primaryNames.zipWithIndex.sortBy{ case (n, _) => -n.length})
+ 
     }
     private final def caseFieldAccessorsUnsorted: List[Symbol] = info.decls.toList.filter(_.isCaseAccessorMethod)
 
diff --git a/test/files/run/t8831.check b/test/files/run/t8831.check
new file mode 100644
index 000000000000..5680b2c3e502
--- /dev/null
+++ b/test/files/run/t8831.check
@@ -0,0 +1 @@
+Right5(1,2,3,4,5)
\ No newline at end of file
diff --git a/test/files/run/t8831.scala b/test/files/run/t8831.scala
new file mode 100644
index 000000000000..65ab7cd3ec35
--- /dev/null
+++ b/test/files/run/t8831.scala
@@ -0,0 +1,47 @@
+case class Right(a: Int, `a b`: Int)
+case class VeryRight(a: Int, `a b`: String)
+
+case class Wrong(`a b`: Int, a: Int)
+case class VeryWrong(`a b`: Int, a: String)
+case class WrongDollar(a$: Int, a: Int)
+case class VeryWrongDollar(a$: Int, a: String)
+case class WrongQuotedDollar(`a$`: Int, a: Int)
+case class WrongHyphenated(val `foo-bar`: Int, `foo`: Int)
+case class VeryWrongHyphenated(val `foo-bar`: Int, `foo`: String)
+case class WrongPlus(a_+ : Int, a_ : Int)
+case class VeryWrongPlus(a_+ : Int, a_ : String)
+
+case class Right5(b: Int, `a b`: Int, a: Int, `a `: Int, `a b c`: Int)
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val r = Right(1, 2)
+    val w = Wrong(1, 2)
+    val wd = WrongDollar(1, 2)
+    val wh = WrongHyphenated(1, 2)
+    val wp = WrongPlus(1, 2)
+    assert(r.a == w.`a b`)
+    assert(r.a == wd.a$)
+    assert(r.a == wh.`foo-bar`)
+    assert(r.a == wp.a_+)
+    assert(r.`a b` == w.a)
+    assert(r.`a b` == wd.a)
+    assert(r.`a b` == wh.foo)
+    assert(r.`a b` == wp.a_)
+
+    val vr = VeryRight(1, "one")
+    val vw = VeryWrong(1, "one")
+    val vwd = VeryWrongDollar(1, "one")
+    val vwh = VeryWrongHyphenated(1, "one")
+    val vwp = VeryWrongPlus(1, "one")
+    assert(vr.a == vw.`a b`)
+    assert(vr.a == vwd.a$)
+    assert(vr.a == vwh.`foo-bar`)
+    assert(vr.a == vwp.a_+)
+    assert(vr.`a b` == vw.a)
+    assert(vr.`a b` == vwd.a)
+    assert(vr.`a b` == vwh.foo)
+    assert(vr.`a b` == vwp.a_)
+    println(Right5(1, 2, 3, 4, 5).toString())
+  }
+}
\ No newline at end of file

From b28e1f1613bff97d3ced3478d464c13462953641 Mon Sep 17 00:00:00 2001
From: Martijn Hoekstra <martijn.hoekstra@cargoxs.com>
Date: Sun, 31 May 2020 16:39:39 +0200
Subject: [PATCH 2/4] generate test cases

---
 test/files/run/t8831_many/Classes_1.scala | 2011 +++++++++++++++++++++
 test/files/run/t8831_many/Tests_2.scala   | 1488 +++++++++++++++
 test/files/run/t8831_many/generator.scala |   93 +
 3 files changed, 3592 insertions(+)
 create mode 100644 test/files/run/t8831_many/Classes_1.scala
 create mode 100644 test/files/run/t8831_many/Tests_2.scala
 create mode 100644 test/files/run/t8831_many/generator.scala

diff --git a/test/files/run/t8831_many/Classes_1.scala b/test/files/run/t8831_many/Classes_1.scala
new file mode 100644
index 000000000000..1f10723e8898
--- /dev/null
+++ b/test/files/run/t8831_many/Classes_1.scala
@@ -0,0 +1,2011 @@
+case class Ctpvtpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctpvtpvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+case class Ctpvtvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctpvtvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+case class Ctpvtnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctpvtnf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+case class Ctpvfpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+case class Ctpvfvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+    val p2 = a
+
+  }
+case class Ctpvfnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+    val p2 = a
+
+  }
+case class Ctvtpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctvtpvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+case class Ctvtvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctvtvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+case class Ctvtnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctvtnf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+case class Ctvfpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+case class Ctvfvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
+    val p2 = a
+
+  }
+case class Ctvfnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
+    val p2 = a
+
+  }
+case class Ctntpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctntpvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+case class Ctntvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctntvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+case class Ctntnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Ctntnf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+case class Ctnfpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+case class Ctnfvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
+    val p2 = a
+
+  }
+case class Ctnfnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
+    val p2 = a
+
+  }
+case class Cfpvtpvt[A, B](private val `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfpvtpvf[A, B](private val `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+case class Cfpvtvt[A, B](private val `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfpvtvf[A, B](private val `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+case class Cfpvtnt[A, B](private val `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfpvtnf[A, B](private val `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+case class Cfpvfpvt[A, B](private val `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+case class Cfpvfpvf[A, B](private val `a b`: A, private val a: B){
+    
+  }
+case class Cfpvfvt[A, B](private val `a b`: A, val a: B){
+    val p2 = a
+
+  }
+case class Cfpvfvf[A, B](private val `a b`: A, val a: B){
+    
+  }
+case class Cfpvfnt[A, B](private val `a b`: A,  a: B){
+    val p2 = a
+
+  }
+case class Cfpvfnf[A, B](private val `a b`: A,  a: B){
+    
+  }
+case class Cfvtpvt[A, B](val `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfvtpvf[A, B](val `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+case class Cfvtvt[A, B](val `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfvtvf[A, B](val `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+case class Cfvtnt[A, B](val `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfvtnf[A, B](val `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+case class Cfvfpvt[A, B](val `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+case class Cfvfpvf[A, B](val `a b`: A, private val a: B){
+    
+  }
+case class Cfvfvt[A, B](val `a b`: A, val a: B){
+    val p2 = a
+
+  }
+case class Cfvfvf[A, B](val `a b`: A, val a: B){
+    
+  }
+case class Cfvfnt[A, B](val `a b`: A,  a: B){
+    val p2 = a
+
+  }
+case class Cfvfnf[A, B](val `a b`: A,  a: B){
+    
+  }
+case class Cfntpvt[A, B]( `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfntpvf[A, B]( `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+case class Cfntvt[A, B]( `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfntvf[A, B]( `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+case class Cfntnt[A, B]( `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+case class Cfntnf[A, B]( `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+case class Cfnfpvt[A, B]( `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+case class Cfnfpvf[A, B]( `a b`: A, private val a: B){
+    
+  }
+case class Cfnfvt[A, B]( `a b`: A, val a: B){
+    val p2 = a
+
+  }
+case class Cfnfvf[A, B]( `a b`: A, val a: B){
+    
+  }
+case class Cfnfnt[A, B]( `a b`: A,  a: B){
+    val p2 = a
+
+  }
+case class Cfnfnf[A, B]( `a b`: A,  a: B){
+    
+  }
+ class Rtpvtpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtpvtpvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+ class Rtpvtvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtpvtvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+ class Rtpvtnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtpvtnf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+ class Rtpvfpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+ class Rtpvfvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+    val p2 = a
+
+  }
+ class Rtpvfnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+    val p2 = a
+
+  }
+ class Rtvtpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtvtpvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+ class Rtvtvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtvtvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+ class Rtvtnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtvtnf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+ class Rtvfpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+ class Rtvfvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
+    val p2 = a
+
+  }
+ class Rtvfnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
+    val p2 = a
+
+  }
+ class Rtntpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtntpvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+ class Rtntvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtntvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+ class Rtntnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rtntnf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+ class Rtnfpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+ class Rtnfvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
+    val p2 = a
+
+  }
+ class Rtnfnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
+    val p2 = a
+
+  }
+ class Rfpvtpvt[A, B](private val `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfpvtpvf[A, B](private val `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+ class Rfpvtvt[A, B](private val `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfpvtvf[A, B](private val `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+ class Rfpvtnt[A, B](private val `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfpvtnf[A, B](private val `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+ class Rfpvfpvt[A, B](private val `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+ class Rfpvfpvf[A, B](private val `a b`: A, private val a: B){
+    
+  }
+ class Rfpvfvt[A, B](private val `a b`: A, val a: B){
+    val p2 = a
+
+  }
+ class Rfpvfvf[A, B](private val `a b`: A, val a: B){
+    
+  }
+ class Rfpvfnt[A, B](private val `a b`: A,  a: B){
+    val p2 = a
+
+  }
+ class Rfpvfnf[A, B](private val `a b`: A,  a: B){
+    
+  }
+ class Rfvtpvt[A, B](val `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfvtpvf[A, B](val `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+ class Rfvtvt[A, B](val `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfvtvf[A, B](val `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+ class Rfvtnt[A, B](val `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfvtnf[A, B](val `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+ class Rfvfpvt[A, B](val `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+ class Rfvfpvf[A, B](val `a b`: A, private val a: B){
+    
+  }
+ class Rfvfvt[A, B](val `a b`: A, val a: B){
+    val p2 = a
+
+  }
+ class Rfvfvf[A, B](val `a b`: A, val a: B){
+    
+  }
+ class Rfvfnt[A, B](val `a b`: A,  a: B){
+    val p2 = a
+
+  }
+ class Rfvfnf[A, B](val `a b`: A,  a: B){
+    
+  }
+ class Rfntpvt[A, B]( `a b`: A, private val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfntpvf[A, B]( `a b`: A, private val a: B){
+    val p1 = `a b`
+
+  }
+ class Rfntvt[A, B]( `a b`: A, val a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfntvf[A, B]( `a b`: A, val a: B){
+    val p1 = `a b`
+
+  }
+ class Rfntnt[A, B]( `a b`: A,  a: B){
+    val p1 = `a b`
+val p2 = a
+
+  }
+ class Rfntnf[A, B]( `a b`: A,  a: B){
+    val p1 = `a b`
+
+  }
+ class Rfnfpvt[A, B]( `a b`: A, private val a: B){
+    val p2 = a
+
+  }
+ class Rfnfpvf[A, B]( `a b`: A, private val a: B){
+    
+  }
+ class Rfnfvt[A, B]( `a b`: A, val a: B){
+    val p2 = a
+
+  }
+ class Rfnfvf[A, B]( `a b`: A, val a: B){
+    
+  }
+ class Rfnfnt[A, B]( `a b`: A,  a: B){
+    val p2 = a
+
+  }
+ class Rfnfnf[A, B]( `a b`: A,  a: B){
+    
+  }
+object TestJoint  {
+ def joint(): Unit = {
+
+val ch_Ctpvtpvt = new Ctpvtpvt('a', 'b')
+val i_Ctpvtpvt = new Ctpvtpvt(1, 2)
+val Ctpvtpvt(extracted1i_Ctpvtpvt, extracted2i_Ctpvtpvt) = i_Ctpvtpvt
+val Ctpvtpvt(extracted1ch_Ctpvtpvt, extracted2ch_Ctpvtpvt) = ch_Ctpvtpvt
+assert(1 == extracted1i_Ctpvtpvt)
+assert(2 == extracted2i_Ctpvtpvt)
+assert('a' == extracted1ch_Ctpvtpvt)
+assert('b' == extracted2ch_Ctpvtpvt)
+
+assert(1 == i_Ctpvtpvt.p1)
+assert(2 == i_Ctpvtpvt.p2)
+assert('a' == ch_Ctpvtpvt.p1)
+assert('b' == ch_Ctpvtpvt.p2)
+
+
+val ch_Ctpvtpvf = new Ctpvtpvf('a', 'b')
+val i_Ctpvtpvf = new Ctpvtpvf(1, 2)
+val Ctpvtpvf(extracted1i_Ctpvtpvf, extracted2i_Ctpvtpvf) = i_Ctpvtpvf
+val Ctpvtpvf(extracted1ch_Ctpvtpvf, extracted2ch_Ctpvtpvf) = ch_Ctpvtpvf
+assert(1 == extracted1i_Ctpvtpvf)
+assert(2 == extracted2i_Ctpvtpvf)
+assert('a' == extracted1ch_Ctpvtpvf)
+assert('b' == extracted2ch_Ctpvtpvf)
+
+assert(1 == i_Ctpvtpvf.p1)
+assert('a' == ch_Ctpvtpvf.p1)
+
+
+val ch_Ctpvtvt = new Ctpvtvt('a', 'b')
+val i_Ctpvtvt = new Ctpvtvt(1, 2)
+val Ctpvtvt(extracted1i_Ctpvtvt, extracted2i_Ctpvtvt) = i_Ctpvtvt
+val Ctpvtvt(extracted1ch_Ctpvtvt, extracted2ch_Ctpvtvt) = ch_Ctpvtvt
+assert(1 == extracted1i_Ctpvtvt)
+assert(2 == extracted2i_Ctpvtvt)
+assert('a' == extracted1ch_Ctpvtvt)
+assert('b' == extracted2ch_Ctpvtvt)
+
+assert(2 == i_Ctpvtvt.a)
+assert('b' == ch_Ctpvtvt.a)
+assert(1 == i_Ctpvtvt.p1)
+assert(2 == i_Ctpvtvt.p2)
+assert('a' == ch_Ctpvtvt.p1)
+assert('b' == ch_Ctpvtvt.p2)
+
+
+val ch_Ctpvtvf = new Ctpvtvf('a', 'b')
+val i_Ctpvtvf = new Ctpvtvf(1, 2)
+val Ctpvtvf(extracted1i_Ctpvtvf, extracted2i_Ctpvtvf) = i_Ctpvtvf
+val Ctpvtvf(extracted1ch_Ctpvtvf, extracted2ch_Ctpvtvf) = ch_Ctpvtvf
+assert(1 == extracted1i_Ctpvtvf)
+assert(2 == extracted2i_Ctpvtvf)
+assert('a' == extracted1ch_Ctpvtvf)
+assert('b' == extracted2ch_Ctpvtvf)
+
+assert(2 == i_Ctpvtvf.a)
+assert('b' == ch_Ctpvtvf.a)
+assert(1 == i_Ctpvtvf.p1)
+assert('a' == ch_Ctpvtvf.p1)
+
+
+val ch_Ctpvtnt = new Ctpvtnt('a', 'b')
+val i_Ctpvtnt = new Ctpvtnt(1, 2)
+val Ctpvtnt(extracted1i_Ctpvtnt, extracted2i_Ctpvtnt) = i_Ctpvtnt
+val Ctpvtnt(extracted1ch_Ctpvtnt, extracted2ch_Ctpvtnt) = ch_Ctpvtnt
+assert(1 == extracted1i_Ctpvtnt)
+assert(2 == extracted2i_Ctpvtnt)
+assert('a' == extracted1ch_Ctpvtnt)
+assert('b' == extracted2ch_Ctpvtnt)
+
+assert(2 == i_Ctpvtnt.a)
+assert('b' == ch_Ctpvtnt.a)
+assert(1 == i_Ctpvtnt.p1)
+assert(2 == i_Ctpvtnt.p2)
+assert('a' == ch_Ctpvtnt.p1)
+assert('b' == ch_Ctpvtnt.p2)
+
+
+val ch_Ctpvtnf = new Ctpvtnf('a', 'b')
+val i_Ctpvtnf = new Ctpvtnf(1, 2)
+val Ctpvtnf(extracted1i_Ctpvtnf, extracted2i_Ctpvtnf) = i_Ctpvtnf
+val Ctpvtnf(extracted1ch_Ctpvtnf, extracted2ch_Ctpvtnf) = ch_Ctpvtnf
+assert(1 == extracted1i_Ctpvtnf)
+assert(2 == extracted2i_Ctpvtnf)
+assert('a' == extracted1ch_Ctpvtnf)
+assert('b' == extracted2ch_Ctpvtnf)
+
+assert(2 == i_Ctpvtnf.a)
+assert('b' == ch_Ctpvtnf.a)
+assert(1 == i_Ctpvtnf.p1)
+assert('a' == ch_Ctpvtnf.p1)
+
+
+val ch_Ctpvfpvt = new Ctpvfpvt('a', 'b')
+val i_Ctpvfpvt = new Ctpvfpvt(1, 2)
+val Ctpvfpvt(extracted1i_Ctpvfpvt, extracted2i_Ctpvfpvt) = i_Ctpvfpvt
+val Ctpvfpvt(extracted1ch_Ctpvfpvt, extracted2ch_Ctpvfpvt) = ch_Ctpvfpvt
+assert(1 == extracted1i_Ctpvfpvt)
+assert(2 == extracted2i_Ctpvfpvt)
+assert('a' == extracted1ch_Ctpvfpvt)
+assert('b' == extracted2ch_Ctpvfpvt)
+
+assert(2 == i_Ctpvfpvt.p2)
+assert('b' == ch_Ctpvfpvt.p2)
+
+
+val ch_Ctpvfvt = new Ctpvfvt('a', 'b')
+val i_Ctpvfvt = new Ctpvfvt(1, 2)
+val Ctpvfvt(extracted1i_Ctpvfvt, extracted2i_Ctpvfvt) = i_Ctpvfvt
+val Ctpvfvt(extracted1ch_Ctpvfvt, extracted2ch_Ctpvfvt) = ch_Ctpvfvt
+assert(1 == extracted1i_Ctpvfvt)
+assert(2 == extracted2i_Ctpvfvt)
+assert('a' == extracted1ch_Ctpvfvt)
+assert('b' == extracted2ch_Ctpvfvt)
+
+assert(2 == i_Ctpvfvt.a)
+assert('b' == ch_Ctpvfvt.a)
+assert(2 == i_Ctpvfvt.p2)
+assert('b' == ch_Ctpvfvt.p2)
+
+
+val ch_Ctpvfnt = new Ctpvfnt('a', 'b')
+val i_Ctpvfnt = new Ctpvfnt(1, 2)
+val Ctpvfnt(extracted1i_Ctpvfnt, extracted2i_Ctpvfnt) = i_Ctpvfnt
+val Ctpvfnt(extracted1ch_Ctpvfnt, extracted2ch_Ctpvfnt) = ch_Ctpvfnt
+assert(1 == extracted1i_Ctpvfnt)
+assert(2 == extracted2i_Ctpvfnt)
+assert('a' == extracted1ch_Ctpvfnt)
+assert('b' == extracted2ch_Ctpvfnt)
+
+assert(2 == i_Ctpvfnt.a)
+assert('b' == ch_Ctpvfnt.a)
+assert(2 == i_Ctpvfnt.p2)
+assert('b' == ch_Ctpvfnt.p2)
+
+
+val ch_Ctvtpvt = new Ctvtpvt('a', 'b')
+val i_Ctvtpvt = new Ctvtpvt(1, 2)
+val Ctvtpvt(extracted1i_Ctvtpvt, extracted2i_Ctvtpvt) = i_Ctvtpvt
+val Ctvtpvt(extracted1ch_Ctvtpvt, extracted2ch_Ctvtpvt) = ch_Ctvtpvt
+assert(1 == extracted1i_Ctvtpvt)
+assert(2 == extracted2i_Ctvtpvt)
+assert('a' == extracted1ch_Ctvtpvt)
+assert('b' == extracted2ch_Ctvtpvt)
+
+assert(1 == i_Ctvtpvt.`a b`)
+assert('a' == ch_Ctvtpvt.`a b`)
+assert(1 == i_Ctvtpvt.p1)
+assert(2 == i_Ctvtpvt.p2)
+assert('a' == ch_Ctvtpvt.p1)
+assert('b' == ch_Ctvtpvt.p2)
+
+
+val ch_Ctvtpvf = new Ctvtpvf('a', 'b')
+val i_Ctvtpvf = new Ctvtpvf(1, 2)
+val Ctvtpvf(extracted1i_Ctvtpvf, extracted2i_Ctvtpvf) = i_Ctvtpvf
+val Ctvtpvf(extracted1ch_Ctvtpvf, extracted2ch_Ctvtpvf) = ch_Ctvtpvf
+assert(1 == extracted1i_Ctvtpvf)
+assert(2 == extracted2i_Ctvtpvf)
+assert('a' == extracted1ch_Ctvtpvf)
+assert('b' == extracted2ch_Ctvtpvf)
+
+assert(1 == i_Ctvtpvf.`a b`)
+assert('a' == ch_Ctvtpvf.`a b`)
+assert(1 == i_Ctvtpvf.p1)
+assert('a' == ch_Ctvtpvf.p1)
+
+
+val ch_Ctvtvt = new Ctvtvt('a', 'b')
+val i_Ctvtvt = new Ctvtvt(1, 2)
+val Ctvtvt(extracted1i_Ctvtvt, extracted2i_Ctvtvt) = i_Ctvtvt
+val Ctvtvt(extracted1ch_Ctvtvt, extracted2ch_Ctvtvt) = ch_Ctvtvt
+assert(1 == extracted1i_Ctvtvt)
+assert(2 == extracted2i_Ctvtvt)
+assert('a' == extracted1ch_Ctvtvt)
+assert('b' == extracted2ch_Ctvtvt)
+
+assert(1 == i_Ctvtvt.`a b`)
+assert(2 == i_Ctvtvt.a)
+assert('a' == ch_Ctvtvt.`a b`)
+assert('b' == ch_Ctvtvt.a)
+assert(1 == i_Ctvtvt.p1)
+assert(2 == i_Ctvtvt.p2)
+assert('a' == ch_Ctvtvt.p1)
+assert('b' == ch_Ctvtvt.p2)
+
+
+val ch_Ctvtvf = new Ctvtvf('a', 'b')
+val i_Ctvtvf = new Ctvtvf(1, 2)
+val Ctvtvf(extracted1i_Ctvtvf, extracted2i_Ctvtvf) = i_Ctvtvf
+val Ctvtvf(extracted1ch_Ctvtvf, extracted2ch_Ctvtvf) = ch_Ctvtvf
+assert(1 == extracted1i_Ctvtvf)
+assert(2 == extracted2i_Ctvtvf)
+assert('a' == extracted1ch_Ctvtvf)
+assert('b' == extracted2ch_Ctvtvf)
+
+assert(1 == i_Ctvtvf.`a b`)
+assert(2 == i_Ctvtvf.a)
+assert('a' == ch_Ctvtvf.`a b`)
+assert('b' == ch_Ctvtvf.a)
+assert(1 == i_Ctvtvf.p1)
+assert('a' == ch_Ctvtvf.p1)
+
+
+val ch_Ctvtnt = new Ctvtnt('a', 'b')
+val i_Ctvtnt = new Ctvtnt(1, 2)
+val Ctvtnt(extracted1i_Ctvtnt, extracted2i_Ctvtnt) = i_Ctvtnt
+val Ctvtnt(extracted1ch_Ctvtnt, extracted2ch_Ctvtnt) = ch_Ctvtnt
+assert(1 == extracted1i_Ctvtnt)
+assert(2 == extracted2i_Ctvtnt)
+assert('a' == extracted1ch_Ctvtnt)
+assert('b' == extracted2ch_Ctvtnt)
+
+assert(1 == i_Ctvtnt.`a b`)
+assert(2 == i_Ctvtnt.a)
+assert('a' == ch_Ctvtnt.`a b`)
+assert('b' == ch_Ctvtnt.a)
+assert(1 == i_Ctvtnt.p1)
+assert(2 == i_Ctvtnt.p2)
+assert('a' == ch_Ctvtnt.p1)
+assert('b' == ch_Ctvtnt.p2)
+
+
+val ch_Ctvtnf = new Ctvtnf('a', 'b')
+val i_Ctvtnf = new Ctvtnf(1, 2)
+val Ctvtnf(extracted1i_Ctvtnf, extracted2i_Ctvtnf) = i_Ctvtnf
+val Ctvtnf(extracted1ch_Ctvtnf, extracted2ch_Ctvtnf) = ch_Ctvtnf
+assert(1 == extracted1i_Ctvtnf)
+assert(2 == extracted2i_Ctvtnf)
+assert('a' == extracted1ch_Ctvtnf)
+assert('b' == extracted2ch_Ctvtnf)
+
+assert(1 == i_Ctvtnf.`a b`)
+assert(2 == i_Ctvtnf.a)
+assert('a' == ch_Ctvtnf.`a b`)
+assert('b' == ch_Ctvtnf.a)
+assert(1 == i_Ctvtnf.p1)
+assert('a' == ch_Ctvtnf.p1)
+
+
+val ch_Ctvfpvt = new Ctvfpvt('a', 'b')
+val i_Ctvfpvt = new Ctvfpvt(1, 2)
+val Ctvfpvt(extracted1i_Ctvfpvt, extracted2i_Ctvfpvt) = i_Ctvfpvt
+val Ctvfpvt(extracted1ch_Ctvfpvt, extracted2ch_Ctvfpvt) = ch_Ctvfpvt
+assert(1 == extracted1i_Ctvfpvt)
+assert(2 == extracted2i_Ctvfpvt)
+assert('a' == extracted1ch_Ctvfpvt)
+assert('b' == extracted2ch_Ctvfpvt)
+
+assert(1 == i_Ctvfpvt.`a b`)
+assert('a' == ch_Ctvfpvt.`a b`)
+assert(2 == i_Ctvfpvt.p2)
+assert('b' == ch_Ctvfpvt.p2)
+
+
+val ch_Ctvfvt = new Ctvfvt('a', 'b')
+val i_Ctvfvt = new Ctvfvt(1, 2)
+val Ctvfvt(extracted1i_Ctvfvt, extracted2i_Ctvfvt) = i_Ctvfvt
+val Ctvfvt(extracted1ch_Ctvfvt, extracted2ch_Ctvfvt) = ch_Ctvfvt
+assert(1 == extracted1i_Ctvfvt)
+assert(2 == extracted2i_Ctvfvt)
+assert('a' == extracted1ch_Ctvfvt)
+assert('b' == extracted2ch_Ctvfvt)
+
+assert(1 == i_Ctvfvt.`a b`)
+assert(2 == i_Ctvfvt.a)
+assert('a' == ch_Ctvfvt.`a b`)
+assert('b' == ch_Ctvfvt.a)
+assert(2 == i_Ctvfvt.p2)
+assert('b' == ch_Ctvfvt.p2)
+
+
+val ch_Ctvfnt = new Ctvfnt('a', 'b')
+val i_Ctvfnt = new Ctvfnt(1, 2)
+val Ctvfnt(extracted1i_Ctvfnt, extracted2i_Ctvfnt) = i_Ctvfnt
+val Ctvfnt(extracted1ch_Ctvfnt, extracted2ch_Ctvfnt) = ch_Ctvfnt
+assert(1 == extracted1i_Ctvfnt)
+assert(2 == extracted2i_Ctvfnt)
+assert('a' == extracted1ch_Ctvfnt)
+assert('b' == extracted2ch_Ctvfnt)
+
+assert(1 == i_Ctvfnt.`a b`)
+assert(2 == i_Ctvfnt.a)
+assert('a' == ch_Ctvfnt.`a b`)
+assert('b' == ch_Ctvfnt.a)
+assert(2 == i_Ctvfnt.p2)
+assert('b' == ch_Ctvfnt.p2)
+
+
+val ch_Ctntpvt = new Ctntpvt('a', 'b')
+val i_Ctntpvt = new Ctntpvt(1, 2)
+val Ctntpvt(extracted1i_Ctntpvt, extracted2i_Ctntpvt) = i_Ctntpvt
+val Ctntpvt(extracted1ch_Ctntpvt, extracted2ch_Ctntpvt) = ch_Ctntpvt
+assert(1 == extracted1i_Ctntpvt)
+assert(2 == extracted2i_Ctntpvt)
+assert('a' == extracted1ch_Ctntpvt)
+assert('b' == extracted2ch_Ctntpvt)
+
+assert(1 == i_Ctntpvt.`a b`)
+assert('a' == ch_Ctntpvt.`a b`)
+assert(1 == i_Ctntpvt.p1)
+assert(2 == i_Ctntpvt.p2)
+assert('a' == ch_Ctntpvt.p1)
+assert('b' == ch_Ctntpvt.p2)
+
+
+val ch_Ctntpvf = new Ctntpvf('a', 'b')
+val i_Ctntpvf = new Ctntpvf(1, 2)
+val Ctntpvf(extracted1i_Ctntpvf, extracted2i_Ctntpvf) = i_Ctntpvf
+val Ctntpvf(extracted1ch_Ctntpvf, extracted2ch_Ctntpvf) = ch_Ctntpvf
+assert(1 == extracted1i_Ctntpvf)
+assert(2 == extracted2i_Ctntpvf)
+assert('a' == extracted1ch_Ctntpvf)
+assert('b' == extracted2ch_Ctntpvf)
+
+assert(1 == i_Ctntpvf.`a b`)
+assert('a' == ch_Ctntpvf.`a b`)
+assert(1 == i_Ctntpvf.p1)
+assert('a' == ch_Ctntpvf.p1)
+
+
+val ch_Ctntvt = new Ctntvt('a', 'b')
+val i_Ctntvt = new Ctntvt(1, 2)
+val Ctntvt(extracted1i_Ctntvt, extracted2i_Ctntvt) = i_Ctntvt
+val Ctntvt(extracted1ch_Ctntvt, extracted2ch_Ctntvt) = ch_Ctntvt
+assert(1 == extracted1i_Ctntvt)
+assert(2 == extracted2i_Ctntvt)
+assert('a' == extracted1ch_Ctntvt)
+assert('b' == extracted2ch_Ctntvt)
+
+assert(1 == i_Ctntvt.`a b`)
+assert(2 == i_Ctntvt.a)
+assert('a' == ch_Ctntvt.`a b`)
+assert('b' == ch_Ctntvt.a)
+assert(1 == i_Ctntvt.p1)
+assert(2 == i_Ctntvt.p2)
+assert('a' == ch_Ctntvt.p1)
+assert('b' == ch_Ctntvt.p2)
+
+
+val ch_Ctntvf = new Ctntvf('a', 'b')
+val i_Ctntvf = new Ctntvf(1, 2)
+val Ctntvf(extracted1i_Ctntvf, extracted2i_Ctntvf) = i_Ctntvf
+val Ctntvf(extracted1ch_Ctntvf, extracted2ch_Ctntvf) = ch_Ctntvf
+assert(1 == extracted1i_Ctntvf)
+assert(2 == extracted2i_Ctntvf)
+assert('a' == extracted1ch_Ctntvf)
+assert('b' == extracted2ch_Ctntvf)
+
+assert(1 == i_Ctntvf.`a b`)
+assert(2 == i_Ctntvf.a)
+assert('a' == ch_Ctntvf.`a b`)
+assert('b' == ch_Ctntvf.a)
+assert(1 == i_Ctntvf.p1)
+assert('a' == ch_Ctntvf.p1)
+
+
+val ch_Ctntnt = new Ctntnt('a', 'b')
+val i_Ctntnt = new Ctntnt(1, 2)
+val Ctntnt(extracted1i_Ctntnt, extracted2i_Ctntnt) = i_Ctntnt
+val Ctntnt(extracted1ch_Ctntnt, extracted2ch_Ctntnt) = ch_Ctntnt
+assert(1 == extracted1i_Ctntnt)
+assert(2 == extracted2i_Ctntnt)
+assert('a' == extracted1ch_Ctntnt)
+assert('b' == extracted2ch_Ctntnt)
+
+assert(1 == i_Ctntnt.`a b`)
+assert(2 == i_Ctntnt.a)
+assert('a' == ch_Ctntnt.`a b`)
+assert('b' == ch_Ctntnt.a)
+assert(1 == i_Ctntnt.p1)
+assert(2 == i_Ctntnt.p2)
+assert('a' == ch_Ctntnt.p1)
+assert('b' == ch_Ctntnt.p2)
+
+
+val ch_Ctntnf = new Ctntnf('a', 'b')
+val i_Ctntnf = new Ctntnf(1, 2)
+val Ctntnf(extracted1i_Ctntnf, extracted2i_Ctntnf) = i_Ctntnf
+val Ctntnf(extracted1ch_Ctntnf, extracted2ch_Ctntnf) = ch_Ctntnf
+assert(1 == extracted1i_Ctntnf)
+assert(2 == extracted2i_Ctntnf)
+assert('a' == extracted1ch_Ctntnf)
+assert('b' == extracted2ch_Ctntnf)
+
+assert(1 == i_Ctntnf.`a b`)
+assert(2 == i_Ctntnf.a)
+assert('a' == ch_Ctntnf.`a b`)
+assert('b' == ch_Ctntnf.a)
+assert(1 == i_Ctntnf.p1)
+assert('a' == ch_Ctntnf.p1)
+
+
+val ch_Ctnfpvt = new Ctnfpvt('a', 'b')
+val i_Ctnfpvt = new Ctnfpvt(1, 2)
+val Ctnfpvt(extracted1i_Ctnfpvt, extracted2i_Ctnfpvt) = i_Ctnfpvt
+val Ctnfpvt(extracted1ch_Ctnfpvt, extracted2ch_Ctnfpvt) = ch_Ctnfpvt
+assert(1 == extracted1i_Ctnfpvt)
+assert(2 == extracted2i_Ctnfpvt)
+assert('a' == extracted1ch_Ctnfpvt)
+assert('b' == extracted2ch_Ctnfpvt)
+
+assert(1 == i_Ctnfpvt.`a b`)
+assert('a' == ch_Ctnfpvt.`a b`)
+assert(2 == i_Ctnfpvt.p2)
+assert('b' == ch_Ctnfpvt.p2)
+
+
+val ch_Ctnfvt = new Ctnfvt('a', 'b')
+val i_Ctnfvt = new Ctnfvt(1, 2)
+val Ctnfvt(extracted1i_Ctnfvt, extracted2i_Ctnfvt) = i_Ctnfvt
+val Ctnfvt(extracted1ch_Ctnfvt, extracted2ch_Ctnfvt) = ch_Ctnfvt
+assert(1 == extracted1i_Ctnfvt)
+assert(2 == extracted2i_Ctnfvt)
+assert('a' == extracted1ch_Ctnfvt)
+assert('b' == extracted2ch_Ctnfvt)
+
+assert(1 == i_Ctnfvt.`a b`)
+assert(2 == i_Ctnfvt.a)
+assert('a' == ch_Ctnfvt.`a b`)
+assert('b' == ch_Ctnfvt.a)
+assert(2 == i_Ctnfvt.p2)
+assert('b' == ch_Ctnfvt.p2)
+
+
+val ch_Ctnfnt = new Ctnfnt('a', 'b')
+val i_Ctnfnt = new Ctnfnt(1, 2)
+val Ctnfnt(extracted1i_Ctnfnt, extracted2i_Ctnfnt) = i_Ctnfnt
+val Ctnfnt(extracted1ch_Ctnfnt, extracted2ch_Ctnfnt) = ch_Ctnfnt
+assert(1 == extracted1i_Ctnfnt)
+assert(2 == extracted2i_Ctnfnt)
+assert('a' == extracted1ch_Ctnfnt)
+assert('b' == extracted2ch_Ctnfnt)
+
+assert(1 == i_Ctnfnt.`a b`)
+assert(2 == i_Ctnfnt.a)
+assert('a' == ch_Ctnfnt.`a b`)
+assert('b' == ch_Ctnfnt.a)
+assert(2 == i_Ctnfnt.p2)
+assert('b' == ch_Ctnfnt.p2)
+
+
+val ch_Cfpvtpvt = new Cfpvtpvt('a', 'b')
+val i_Cfpvtpvt = new Cfpvtpvt(1, 2)
+val Cfpvtpvt(extracted1i_Cfpvtpvt, extracted2i_Cfpvtpvt) = i_Cfpvtpvt
+val Cfpvtpvt(extracted1ch_Cfpvtpvt, extracted2ch_Cfpvtpvt) = ch_Cfpvtpvt
+assert(1 == extracted1i_Cfpvtpvt)
+assert(2 == extracted2i_Cfpvtpvt)
+assert('a' == extracted1ch_Cfpvtpvt)
+assert('b' == extracted2ch_Cfpvtpvt)
+
+assert(1 == i_Cfpvtpvt.p1)
+assert(2 == i_Cfpvtpvt.p2)
+assert('a' == ch_Cfpvtpvt.p1)
+assert('b' == ch_Cfpvtpvt.p2)
+
+
+val ch_Cfpvtpvf = new Cfpvtpvf('a', 'b')
+val i_Cfpvtpvf = new Cfpvtpvf(1, 2)
+val Cfpvtpvf(extracted1i_Cfpvtpvf, extracted2i_Cfpvtpvf) = i_Cfpvtpvf
+val Cfpvtpvf(extracted1ch_Cfpvtpvf, extracted2ch_Cfpvtpvf) = ch_Cfpvtpvf
+assert(1 == extracted1i_Cfpvtpvf)
+assert(2 == extracted2i_Cfpvtpvf)
+assert('a' == extracted1ch_Cfpvtpvf)
+assert('b' == extracted2ch_Cfpvtpvf)
+
+assert(1 == i_Cfpvtpvf.p1)
+assert('a' == ch_Cfpvtpvf.p1)
+
+
+val ch_Cfpvtvt = new Cfpvtvt('a', 'b')
+val i_Cfpvtvt = new Cfpvtvt(1, 2)
+val Cfpvtvt(extracted1i_Cfpvtvt, extracted2i_Cfpvtvt) = i_Cfpvtvt
+val Cfpvtvt(extracted1ch_Cfpvtvt, extracted2ch_Cfpvtvt) = ch_Cfpvtvt
+assert(1 == extracted1i_Cfpvtvt)
+assert(2 == extracted2i_Cfpvtvt)
+assert('a' == extracted1ch_Cfpvtvt)
+assert('b' == extracted2ch_Cfpvtvt)
+
+assert(2 == i_Cfpvtvt.a)
+assert('b' == ch_Cfpvtvt.a)
+assert(1 == i_Cfpvtvt.p1)
+assert(2 == i_Cfpvtvt.p2)
+assert('a' == ch_Cfpvtvt.p1)
+assert('b' == ch_Cfpvtvt.p2)
+
+
+val ch_Cfpvtvf = new Cfpvtvf('a', 'b')
+val i_Cfpvtvf = new Cfpvtvf(1, 2)
+val Cfpvtvf(extracted1i_Cfpvtvf, extracted2i_Cfpvtvf) = i_Cfpvtvf
+val Cfpvtvf(extracted1ch_Cfpvtvf, extracted2ch_Cfpvtvf) = ch_Cfpvtvf
+assert(1 == extracted1i_Cfpvtvf)
+assert(2 == extracted2i_Cfpvtvf)
+assert('a' == extracted1ch_Cfpvtvf)
+assert('b' == extracted2ch_Cfpvtvf)
+
+assert(2 == i_Cfpvtvf.a)
+assert('b' == ch_Cfpvtvf.a)
+assert(1 == i_Cfpvtvf.p1)
+assert('a' == ch_Cfpvtvf.p1)
+
+
+val ch_Cfpvtnt = new Cfpvtnt('a', 'b')
+val i_Cfpvtnt = new Cfpvtnt(1, 2)
+val Cfpvtnt(extracted1i_Cfpvtnt, extracted2i_Cfpvtnt) = i_Cfpvtnt
+val Cfpvtnt(extracted1ch_Cfpvtnt, extracted2ch_Cfpvtnt) = ch_Cfpvtnt
+assert(1 == extracted1i_Cfpvtnt)
+assert(2 == extracted2i_Cfpvtnt)
+assert('a' == extracted1ch_Cfpvtnt)
+assert('b' == extracted2ch_Cfpvtnt)
+
+assert(2 == i_Cfpvtnt.a)
+assert('b' == ch_Cfpvtnt.a)
+assert(1 == i_Cfpvtnt.p1)
+assert(2 == i_Cfpvtnt.p2)
+assert('a' == ch_Cfpvtnt.p1)
+assert('b' == ch_Cfpvtnt.p2)
+
+
+val ch_Cfpvtnf = new Cfpvtnf('a', 'b')
+val i_Cfpvtnf = new Cfpvtnf(1, 2)
+val Cfpvtnf(extracted1i_Cfpvtnf, extracted2i_Cfpvtnf) = i_Cfpvtnf
+val Cfpvtnf(extracted1ch_Cfpvtnf, extracted2ch_Cfpvtnf) = ch_Cfpvtnf
+assert(1 == extracted1i_Cfpvtnf)
+assert(2 == extracted2i_Cfpvtnf)
+assert('a' == extracted1ch_Cfpvtnf)
+assert('b' == extracted2ch_Cfpvtnf)
+
+assert(2 == i_Cfpvtnf.a)
+assert('b' == ch_Cfpvtnf.a)
+assert(1 == i_Cfpvtnf.p1)
+assert('a' == ch_Cfpvtnf.p1)
+
+
+val ch_Cfpvfpvt = new Cfpvfpvt('a', 'b')
+val i_Cfpvfpvt = new Cfpvfpvt(1, 2)
+val Cfpvfpvt(extracted1i_Cfpvfpvt, extracted2i_Cfpvfpvt) = i_Cfpvfpvt
+val Cfpvfpvt(extracted1ch_Cfpvfpvt, extracted2ch_Cfpvfpvt) = ch_Cfpvfpvt
+assert(1 == extracted1i_Cfpvfpvt)
+assert(2 == extracted2i_Cfpvfpvt)
+assert('a' == extracted1ch_Cfpvfpvt)
+assert('b' == extracted2ch_Cfpvfpvt)
+
+assert(2 == i_Cfpvfpvt.p2)
+assert('b' == ch_Cfpvfpvt.p2)
+
+
+val ch_Cfpvfpvf = new Cfpvfpvf('a', 'b')
+val i_Cfpvfpvf = new Cfpvfpvf(1, 2)
+val Cfpvfpvf(extracted1i_Cfpvfpvf, extracted2i_Cfpvfpvf) = i_Cfpvfpvf
+val Cfpvfpvf(extracted1ch_Cfpvfpvf, extracted2ch_Cfpvfpvf) = ch_Cfpvfpvf
+assert(1 == extracted1i_Cfpvfpvf)
+assert(2 == extracted2i_Cfpvfpvf)
+assert('a' == extracted1ch_Cfpvfpvf)
+assert('b' == extracted2ch_Cfpvfpvf)
+
+
+
+val ch_Cfpvfvt = new Cfpvfvt('a', 'b')
+val i_Cfpvfvt = new Cfpvfvt(1, 2)
+val Cfpvfvt(extracted1i_Cfpvfvt, extracted2i_Cfpvfvt) = i_Cfpvfvt
+val Cfpvfvt(extracted1ch_Cfpvfvt, extracted2ch_Cfpvfvt) = ch_Cfpvfvt
+assert(1 == extracted1i_Cfpvfvt)
+assert(2 == extracted2i_Cfpvfvt)
+assert('a' == extracted1ch_Cfpvfvt)
+assert('b' == extracted2ch_Cfpvfvt)
+
+assert(2 == i_Cfpvfvt.a)
+assert('b' == ch_Cfpvfvt.a)
+assert(2 == i_Cfpvfvt.p2)
+assert('b' == ch_Cfpvfvt.p2)
+
+
+val ch_Cfpvfvf = new Cfpvfvf('a', 'b')
+val i_Cfpvfvf = new Cfpvfvf(1, 2)
+val Cfpvfvf(extracted1i_Cfpvfvf, extracted2i_Cfpvfvf) = i_Cfpvfvf
+val Cfpvfvf(extracted1ch_Cfpvfvf, extracted2ch_Cfpvfvf) = ch_Cfpvfvf
+assert(1 == extracted1i_Cfpvfvf)
+assert(2 == extracted2i_Cfpvfvf)
+assert('a' == extracted1ch_Cfpvfvf)
+assert('b' == extracted2ch_Cfpvfvf)
+
+assert(2 == i_Cfpvfvf.a)
+assert('b' == ch_Cfpvfvf.a)
+
+
+val ch_Cfpvfnt = new Cfpvfnt('a', 'b')
+val i_Cfpvfnt = new Cfpvfnt(1, 2)
+val Cfpvfnt(extracted1i_Cfpvfnt, extracted2i_Cfpvfnt) = i_Cfpvfnt
+val Cfpvfnt(extracted1ch_Cfpvfnt, extracted2ch_Cfpvfnt) = ch_Cfpvfnt
+assert(1 == extracted1i_Cfpvfnt)
+assert(2 == extracted2i_Cfpvfnt)
+assert('a' == extracted1ch_Cfpvfnt)
+assert('b' == extracted2ch_Cfpvfnt)
+
+assert(2 == i_Cfpvfnt.a)
+assert('b' == ch_Cfpvfnt.a)
+assert(2 == i_Cfpvfnt.p2)
+assert('b' == ch_Cfpvfnt.p2)
+
+
+val ch_Cfpvfnf = new Cfpvfnf('a', 'b')
+val i_Cfpvfnf = new Cfpvfnf(1, 2)
+val Cfpvfnf(extracted1i_Cfpvfnf, extracted2i_Cfpvfnf) = i_Cfpvfnf
+val Cfpvfnf(extracted1ch_Cfpvfnf, extracted2ch_Cfpvfnf) = ch_Cfpvfnf
+assert(1 == extracted1i_Cfpvfnf)
+assert(2 == extracted2i_Cfpvfnf)
+assert('a' == extracted1ch_Cfpvfnf)
+assert('b' == extracted2ch_Cfpvfnf)
+
+assert(2 == i_Cfpvfnf.a)
+assert('b' == ch_Cfpvfnf.a)
+
+
+val ch_Cfvtpvt = new Cfvtpvt('a', 'b')
+val i_Cfvtpvt = new Cfvtpvt(1, 2)
+val Cfvtpvt(extracted1i_Cfvtpvt, extracted2i_Cfvtpvt) = i_Cfvtpvt
+val Cfvtpvt(extracted1ch_Cfvtpvt, extracted2ch_Cfvtpvt) = ch_Cfvtpvt
+assert(1 == extracted1i_Cfvtpvt)
+assert(2 == extracted2i_Cfvtpvt)
+assert('a' == extracted1ch_Cfvtpvt)
+assert('b' == extracted2ch_Cfvtpvt)
+
+assert(1 == i_Cfvtpvt.`a b`)
+assert('a' == ch_Cfvtpvt.`a b`)
+assert(1 == i_Cfvtpvt.p1)
+assert(2 == i_Cfvtpvt.p2)
+assert('a' == ch_Cfvtpvt.p1)
+assert('b' == ch_Cfvtpvt.p2)
+
+
+val ch_Cfvtpvf = new Cfvtpvf('a', 'b')
+val i_Cfvtpvf = new Cfvtpvf(1, 2)
+val Cfvtpvf(extracted1i_Cfvtpvf, extracted2i_Cfvtpvf) = i_Cfvtpvf
+val Cfvtpvf(extracted1ch_Cfvtpvf, extracted2ch_Cfvtpvf) = ch_Cfvtpvf
+assert(1 == extracted1i_Cfvtpvf)
+assert(2 == extracted2i_Cfvtpvf)
+assert('a' == extracted1ch_Cfvtpvf)
+assert('b' == extracted2ch_Cfvtpvf)
+
+assert(1 == i_Cfvtpvf.`a b`)
+assert('a' == ch_Cfvtpvf.`a b`)
+assert(1 == i_Cfvtpvf.p1)
+assert('a' == ch_Cfvtpvf.p1)
+
+
+val ch_Cfvtvt = new Cfvtvt('a', 'b')
+val i_Cfvtvt = new Cfvtvt(1, 2)
+val Cfvtvt(extracted1i_Cfvtvt, extracted2i_Cfvtvt) = i_Cfvtvt
+val Cfvtvt(extracted1ch_Cfvtvt, extracted2ch_Cfvtvt) = ch_Cfvtvt
+assert(1 == extracted1i_Cfvtvt)
+assert(2 == extracted2i_Cfvtvt)
+assert('a' == extracted1ch_Cfvtvt)
+assert('b' == extracted2ch_Cfvtvt)
+
+assert(1 == i_Cfvtvt.`a b`)
+assert(2 == i_Cfvtvt.a)
+assert('a' == ch_Cfvtvt.`a b`)
+assert('b' == ch_Cfvtvt.a)
+assert(1 == i_Cfvtvt.p1)
+assert(2 == i_Cfvtvt.p2)
+assert('a' == ch_Cfvtvt.p1)
+assert('b' == ch_Cfvtvt.p2)
+
+
+val ch_Cfvtvf = new Cfvtvf('a', 'b')
+val i_Cfvtvf = new Cfvtvf(1, 2)
+val Cfvtvf(extracted1i_Cfvtvf, extracted2i_Cfvtvf) = i_Cfvtvf
+val Cfvtvf(extracted1ch_Cfvtvf, extracted2ch_Cfvtvf) = ch_Cfvtvf
+assert(1 == extracted1i_Cfvtvf)
+assert(2 == extracted2i_Cfvtvf)
+assert('a' == extracted1ch_Cfvtvf)
+assert('b' == extracted2ch_Cfvtvf)
+
+assert(1 == i_Cfvtvf.`a b`)
+assert(2 == i_Cfvtvf.a)
+assert('a' == ch_Cfvtvf.`a b`)
+assert('b' == ch_Cfvtvf.a)
+assert(1 == i_Cfvtvf.p1)
+assert('a' == ch_Cfvtvf.p1)
+
+
+val ch_Cfvtnt = new Cfvtnt('a', 'b')
+val i_Cfvtnt = new Cfvtnt(1, 2)
+val Cfvtnt(extracted1i_Cfvtnt, extracted2i_Cfvtnt) = i_Cfvtnt
+val Cfvtnt(extracted1ch_Cfvtnt, extracted2ch_Cfvtnt) = ch_Cfvtnt
+assert(1 == extracted1i_Cfvtnt)
+assert(2 == extracted2i_Cfvtnt)
+assert('a' == extracted1ch_Cfvtnt)
+assert('b' == extracted2ch_Cfvtnt)
+
+assert(1 == i_Cfvtnt.`a b`)
+assert(2 == i_Cfvtnt.a)
+assert('a' == ch_Cfvtnt.`a b`)
+assert('b' == ch_Cfvtnt.a)
+assert(1 == i_Cfvtnt.p1)
+assert(2 == i_Cfvtnt.p2)
+assert('a' == ch_Cfvtnt.p1)
+assert('b' == ch_Cfvtnt.p2)
+
+
+val ch_Cfvtnf = new Cfvtnf('a', 'b')
+val i_Cfvtnf = new Cfvtnf(1, 2)
+val Cfvtnf(extracted1i_Cfvtnf, extracted2i_Cfvtnf) = i_Cfvtnf
+val Cfvtnf(extracted1ch_Cfvtnf, extracted2ch_Cfvtnf) = ch_Cfvtnf
+assert(1 == extracted1i_Cfvtnf)
+assert(2 == extracted2i_Cfvtnf)
+assert('a' == extracted1ch_Cfvtnf)
+assert('b' == extracted2ch_Cfvtnf)
+
+assert(1 == i_Cfvtnf.`a b`)
+assert(2 == i_Cfvtnf.a)
+assert('a' == ch_Cfvtnf.`a b`)
+assert('b' == ch_Cfvtnf.a)
+assert(1 == i_Cfvtnf.p1)
+assert('a' == ch_Cfvtnf.p1)
+
+
+val ch_Cfvfpvt = new Cfvfpvt('a', 'b')
+val i_Cfvfpvt = new Cfvfpvt(1, 2)
+val Cfvfpvt(extracted1i_Cfvfpvt, extracted2i_Cfvfpvt) = i_Cfvfpvt
+val Cfvfpvt(extracted1ch_Cfvfpvt, extracted2ch_Cfvfpvt) = ch_Cfvfpvt
+assert(1 == extracted1i_Cfvfpvt)
+assert(2 == extracted2i_Cfvfpvt)
+assert('a' == extracted1ch_Cfvfpvt)
+assert('b' == extracted2ch_Cfvfpvt)
+
+assert(1 == i_Cfvfpvt.`a b`)
+assert('a' == ch_Cfvfpvt.`a b`)
+assert(2 == i_Cfvfpvt.p2)
+assert('b' == ch_Cfvfpvt.p2)
+
+
+val ch_Cfvfpvf = new Cfvfpvf('a', 'b')
+val i_Cfvfpvf = new Cfvfpvf(1, 2)
+val Cfvfpvf(extracted1i_Cfvfpvf, extracted2i_Cfvfpvf) = i_Cfvfpvf
+val Cfvfpvf(extracted1ch_Cfvfpvf, extracted2ch_Cfvfpvf) = ch_Cfvfpvf
+assert(1 == extracted1i_Cfvfpvf)
+assert(2 == extracted2i_Cfvfpvf)
+assert('a' == extracted1ch_Cfvfpvf)
+assert('b' == extracted2ch_Cfvfpvf)
+
+assert(1 == i_Cfvfpvf.`a b`)
+assert('a' == ch_Cfvfpvf.`a b`)
+
+
+val ch_Cfvfvt = new Cfvfvt('a', 'b')
+val i_Cfvfvt = new Cfvfvt(1, 2)
+val Cfvfvt(extracted1i_Cfvfvt, extracted2i_Cfvfvt) = i_Cfvfvt
+val Cfvfvt(extracted1ch_Cfvfvt, extracted2ch_Cfvfvt) = ch_Cfvfvt
+assert(1 == extracted1i_Cfvfvt)
+assert(2 == extracted2i_Cfvfvt)
+assert('a' == extracted1ch_Cfvfvt)
+assert('b' == extracted2ch_Cfvfvt)
+
+assert(1 == i_Cfvfvt.`a b`)
+assert(2 == i_Cfvfvt.a)
+assert('a' == ch_Cfvfvt.`a b`)
+assert('b' == ch_Cfvfvt.a)
+assert(2 == i_Cfvfvt.p2)
+assert('b' == ch_Cfvfvt.p2)
+
+
+val ch_Cfvfvf = new Cfvfvf('a', 'b')
+val i_Cfvfvf = new Cfvfvf(1, 2)
+val Cfvfvf(extracted1i_Cfvfvf, extracted2i_Cfvfvf) = i_Cfvfvf
+val Cfvfvf(extracted1ch_Cfvfvf, extracted2ch_Cfvfvf) = ch_Cfvfvf
+assert(1 == extracted1i_Cfvfvf)
+assert(2 == extracted2i_Cfvfvf)
+assert('a' == extracted1ch_Cfvfvf)
+assert('b' == extracted2ch_Cfvfvf)
+
+assert(1 == i_Cfvfvf.`a b`)
+assert(2 == i_Cfvfvf.a)
+assert('a' == ch_Cfvfvf.`a b`)
+assert('b' == ch_Cfvfvf.a)
+
+
+val ch_Cfvfnt = new Cfvfnt('a', 'b')
+val i_Cfvfnt = new Cfvfnt(1, 2)
+val Cfvfnt(extracted1i_Cfvfnt, extracted2i_Cfvfnt) = i_Cfvfnt
+val Cfvfnt(extracted1ch_Cfvfnt, extracted2ch_Cfvfnt) = ch_Cfvfnt
+assert(1 == extracted1i_Cfvfnt)
+assert(2 == extracted2i_Cfvfnt)
+assert('a' == extracted1ch_Cfvfnt)
+assert('b' == extracted2ch_Cfvfnt)
+
+assert(1 == i_Cfvfnt.`a b`)
+assert(2 == i_Cfvfnt.a)
+assert('a' == ch_Cfvfnt.`a b`)
+assert('b' == ch_Cfvfnt.a)
+assert(2 == i_Cfvfnt.p2)
+assert('b' == ch_Cfvfnt.p2)
+
+
+val ch_Cfvfnf = new Cfvfnf('a', 'b')
+val i_Cfvfnf = new Cfvfnf(1, 2)
+val Cfvfnf(extracted1i_Cfvfnf, extracted2i_Cfvfnf) = i_Cfvfnf
+val Cfvfnf(extracted1ch_Cfvfnf, extracted2ch_Cfvfnf) = ch_Cfvfnf
+assert(1 == extracted1i_Cfvfnf)
+assert(2 == extracted2i_Cfvfnf)
+assert('a' == extracted1ch_Cfvfnf)
+assert('b' == extracted2ch_Cfvfnf)
+
+assert(1 == i_Cfvfnf.`a b`)
+assert(2 == i_Cfvfnf.a)
+assert('a' == ch_Cfvfnf.`a b`)
+assert('b' == ch_Cfvfnf.a)
+
+
+val ch_Cfntpvt = new Cfntpvt('a', 'b')
+val i_Cfntpvt = new Cfntpvt(1, 2)
+val Cfntpvt(extracted1i_Cfntpvt, extracted2i_Cfntpvt) = i_Cfntpvt
+val Cfntpvt(extracted1ch_Cfntpvt, extracted2ch_Cfntpvt) = ch_Cfntpvt
+assert(1 == extracted1i_Cfntpvt)
+assert(2 == extracted2i_Cfntpvt)
+assert('a' == extracted1ch_Cfntpvt)
+assert('b' == extracted2ch_Cfntpvt)
+
+assert(1 == i_Cfntpvt.`a b`)
+assert('a' == ch_Cfntpvt.`a b`)
+assert(1 == i_Cfntpvt.p1)
+assert(2 == i_Cfntpvt.p2)
+assert('a' == ch_Cfntpvt.p1)
+assert('b' == ch_Cfntpvt.p2)
+
+
+val ch_Cfntpvf = new Cfntpvf('a', 'b')
+val i_Cfntpvf = new Cfntpvf(1, 2)
+val Cfntpvf(extracted1i_Cfntpvf, extracted2i_Cfntpvf) = i_Cfntpvf
+val Cfntpvf(extracted1ch_Cfntpvf, extracted2ch_Cfntpvf) = ch_Cfntpvf
+assert(1 == extracted1i_Cfntpvf)
+assert(2 == extracted2i_Cfntpvf)
+assert('a' == extracted1ch_Cfntpvf)
+assert('b' == extracted2ch_Cfntpvf)
+
+assert(1 == i_Cfntpvf.`a b`)
+assert('a' == ch_Cfntpvf.`a b`)
+assert(1 == i_Cfntpvf.p1)
+assert('a' == ch_Cfntpvf.p1)
+
+
+val ch_Cfntvt = new Cfntvt('a', 'b')
+val i_Cfntvt = new Cfntvt(1, 2)
+val Cfntvt(extracted1i_Cfntvt, extracted2i_Cfntvt) = i_Cfntvt
+val Cfntvt(extracted1ch_Cfntvt, extracted2ch_Cfntvt) = ch_Cfntvt
+assert(1 == extracted1i_Cfntvt)
+assert(2 == extracted2i_Cfntvt)
+assert('a' == extracted1ch_Cfntvt)
+assert('b' == extracted2ch_Cfntvt)
+
+assert(1 == i_Cfntvt.`a b`)
+assert(2 == i_Cfntvt.a)
+assert('a' == ch_Cfntvt.`a b`)
+assert('b' == ch_Cfntvt.a)
+assert(1 == i_Cfntvt.p1)
+assert(2 == i_Cfntvt.p2)
+assert('a' == ch_Cfntvt.p1)
+assert('b' == ch_Cfntvt.p2)
+
+
+val ch_Cfntvf = new Cfntvf('a', 'b')
+val i_Cfntvf = new Cfntvf(1, 2)
+val Cfntvf(extracted1i_Cfntvf, extracted2i_Cfntvf) = i_Cfntvf
+val Cfntvf(extracted1ch_Cfntvf, extracted2ch_Cfntvf) = ch_Cfntvf
+assert(1 == extracted1i_Cfntvf)
+assert(2 == extracted2i_Cfntvf)
+assert('a' == extracted1ch_Cfntvf)
+assert('b' == extracted2ch_Cfntvf)
+
+assert(1 == i_Cfntvf.`a b`)
+assert(2 == i_Cfntvf.a)
+assert('a' == ch_Cfntvf.`a b`)
+assert('b' == ch_Cfntvf.a)
+assert(1 == i_Cfntvf.p1)
+assert('a' == ch_Cfntvf.p1)
+
+
+val ch_Cfntnt = new Cfntnt('a', 'b')
+val i_Cfntnt = new Cfntnt(1, 2)
+val Cfntnt(extracted1i_Cfntnt, extracted2i_Cfntnt) = i_Cfntnt
+val Cfntnt(extracted1ch_Cfntnt, extracted2ch_Cfntnt) = ch_Cfntnt
+assert(1 == extracted1i_Cfntnt)
+assert(2 == extracted2i_Cfntnt)
+assert('a' == extracted1ch_Cfntnt)
+assert('b' == extracted2ch_Cfntnt)
+
+assert(1 == i_Cfntnt.`a b`)
+assert(2 == i_Cfntnt.a)
+assert('a' == ch_Cfntnt.`a b`)
+assert('b' == ch_Cfntnt.a)
+assert(1 == i_Cfntnt.p1)
+assert(2 == i_Cfntnt.p2)
+assert('a' == ch_Cfntnt.p1)
+assert('b' == ch_Cfntnt.p2)
+
+
+val ch_Cfntnf = new Cfntnf('a', 'b')
+val i_Cfntnf = new Cfntnf(1, 2)
+val Cfntnf(extracted1i_Cfntnf, extracted2i_Cfntnf) = i_Cfntnf
+val Cfntnf(extracted1ch_Cfntnf, extracted2ch_Cfntnf) = ch_Cfntnf
+assert(1 == extracted1i_Cfntnf)
+assert(2 == extracted2i_Cfntnf)
+assert('a' == extracted1ch_Cfntnf)
+assert('b' == extracted2ch_Cfntnf)
+
+assert(1 == i_Cfntnf.`a b`)
+assert(2 == i_Cfntnf.a)
+assert('a' == ch_Cfntnf.`a b`)
+assert('b' == ch_Cfntnf.a)
+assert(1 == i_Cfntnf.p1)
+assert('a' == ch_Cfntnf.p1)
+
+
+val ch_Cfnfpvt = new Cfnfpvt('a', 'b')
+val i_Cfnfpvt = new Cfnfpvt(1, 2)
+val Cfnfpvt(extracted1i_Cfnfpvt, extracted2i_Cfnfpvt) = i_Cfnfpvt
+val Cfnfpvt(extracted1ch_Cfnfpvt, extracted2ch_Cfnfpvt) = ch_Cfnfpvt
+assert(1 == extracted1i_Cfnfpvt)
+assert(2 == extracted2i_Cfnfpvt)
+assert('a' == extracted1ch_Cfnfpvt)
+assert('b' == extracted2ch_Cfnfpvt)
+
+assert(1 == i_Cfnfpvt.`a b`)
+assert('a' == ch_Cfnfpvt.`a b`)
+assert(2 == i_Cfnfpvt.p2)
+assert('b' == ch_Cfnfpvt.p2)
+
+
+val ch_Cfnfpvf = new Cfnfpvf('a', 'b')
+val i_Cfnfpvf = new Cfnfpvf(1, 2)
+val Cfnfpvf(extracted1i_Cfnfpvf, extracted2i_Cfnfpvf) = i_Cfnfpvf
+val Cfnfpvf(extracted1ch_Cfnfpvf, extracted2ch_Cfnfpvf) = ch_Cfnfpvf
+assert(1 == extracted1i_Cfnfpvf)
+assert(2 == extracted2i_Cfnfpvf)
+assert('a' == extracted1ch_Cfnfpvf)
+assert('b' == extracted2ch_Cfnfpvf)
+
+assert(1 == i_Cfnfpvf.`a b`)
+assert('a' == ch_Cfnfpvf.`a b`)
+
+
+val ch_Cfnfvt = new Cfnfvt('a', 'b')
+val i_Cfnfvt = new Cfnfvt(1, 2)
+val Cfnfvt(extracted1i_Cfnfvt, extracted2i_Cfnfvt) = i_Cfnfvt
+val Cfnfvt(extracted1ch_Cfnfvt, extracted2ch_Cfnfvt) = ch_Cfnfvt
+assert(1 == extracted1i_Cfnfvt)
+assert(2 == extracted2i_Cfnfvt)
+assert('a' == extracted1ch_Cfnfvt)
+assert('b' == extracted2ch_Cfnfvt)
+
+assert(1 == i_Cfnfvt.`a b`)
+assert(2 == i_Cfnfvt.a)
+assert('a' == ch_Cfnfvt.`a b`)
+assert('b' == ch_Cfnfvt.a)
+assert(2 == i_Cfnfvt.p2)
+assert('b' == ch_Cfnfvt.p2)
+
+
+val ch_Cfnfvf = new Cfnfvf('a', 'b')
+val i_Cfnfvf = new Cfnfvf(1, 2)
+val Cfnfvf(extracted1i_Cfnfvf, extracted2i_Cfnfvf) = i_Cfnfvf
+val Cfnfvf(extracted1ch_Cfnfvf, extracted2ch_Cfnfvf) = ch_Cfnfvf
+assert(1 == extracted1i_Cfnfvf)
+assert(2 == extracted2i_Cfnfvf)
+assert('a' == extracted1ch_Cfnfvf)
+assert('b' == extracted2ch_Cfnfvf)
+
+assert(1 == i_Cfnfvf.`a b`)
+assert(2 == i_Cfnfvf.a)
+assert('a' == ch_Cfnfvf.`a b`)
+assert('b' == ch_Cfnfvf.a)
+
+
+val ch_Cfnfnt = new Cfnfnt('a', 'b')
+val i_Cfnfnt = new Cfnfnt(1, 2)
+val Cfnfnt(extracted1i_Cfnfnt, extracted2i_Cfnfnt) = i_Cfnfnt
+val Cfnfnt(extracted1ch_Cfnfnt, extracted2ch_Cfnfnt) = ch_Cfnfnt
+assert(1 == extracted1i_Cfnfnt)
+assert(2 == extracted2i_Cfnfnt)
+assert('a' == extracted1ch_Cfnfnt)
+assert('b' == extracted2ch_Cfnfnt)
+
+assert(1 == i_Cfnfnt.`a b`)
+assert(2 == i_Cfnfnt.a)
+assert('a' == ch_Cfnfnt.`a b`)
+assert('b' == ch_Cfnfnt.a)
+assert(2 == i_Cfnfnt.p2)
+assert('b' == ch_Cfnfnt.p2)
+
+
+val ch_Cfnfnf = new Cfnfnf('a', 'b')
+val i_Cfnfnf = new Cfnfnf(1, 2)
+val Cfnfnf(extracted1i_Cfnfnf, extracted2i_Cfnfnf) = i_Cfnfnf
+val Cfnfnf(extracted1ch_Cfnfnf, extracted2ch_Cfnfnf) = ch_Cfnfnf
+assert(1 == extracted1i_Cfnfnf)
+assert(2 == extracted2i_Cfnfnf)
+assert('a' == extracted1ch_Cfnfnf)
+assert('b' == extracted2ch_Cfnfnf)
+
+assert(1 == i_Cfnfnf.`a b`)
+assert(2 == i_Cfnfnf.a)
+assert('a' == ch_Cfnfnf.`a b`)
+assert('b' == ch_Cfnfnf.a)
+
+
+val ch_Rtpvtpvt = new Rtpvtpvt('a', 'b')
+val i_Rtpvtpvt = new Rtpvtpvt(1, 2)
+assert(1 == i_Rtpvtpvt.p1)
+assert(2 == i_Rtpvtpvt.p2)
+assert('a' == ch_Rtpvtpvt.p1)
+assert('b' == ch_Rtpvtpvt.p2)
+
+
+val ch_Rtpvtpvf = new Rtpvtpvf('a', 'b')
+val i_Rtpvtpvf = new Rtpvtpvf(1, 2)
+assert(1 == i_Rtpvtpvf.p1)
+assert('a' == ch_Rtpvtpvf.p1)
+
+
+val ch_Rtpvtvt = new Rtpvtvt('a', 'b')
+val i_Rtpvtvt = new Rtpvtvt(1, 2)
+assert(2 == i_Rtpvtvt.a)
+assert('b' == ch_Rtpvtvt.a)
+assert(1 == i_Rtpvtvt.p1)
+assert(2 == i_Rtpvtvt.p2)
+assert('a' == ch_Rtpvtvt.p1)
+assert('b' == ch_Rtpvtvt.p2)
+
+
+val ch_Rtpvtvf = new Rtpvtvf('a', 'b')
+val i_Rtpvtvf = new Rtpvtvf(1, 2)
+assert(2 == i_Rtpvtvf.a)
+assert('b' == ch_Rtpvtvf.a)
+assert(1 == i_Rtpvtvf.p1)
+assert('a' == ch_Rtpvtvf.p1)
+
+
+val ch_Rtpvtnt = new Rtpvtnt('a', 'b')
+val i_Rtpvtnt = new Rtpvtnt(1, 2)
+assert(1 == i_Rtpvtnt.p1)
+assert(2 == i_Rtpvtnt.p2)
+assert('a' == ch_Rtpvtnt.p1)
+assert('b' == ch_Rtpvtnt.p2)
+
+
+val ch_Rtpvtnf = new Rtpvtnf('a', 'b')
+val i_Rtpvtnf = new Rtpvtnf(1, 2)
+assert(1 == i_Rtpvtnf.p1)
+assert('a' == ch_Rtpvtnf.p1)
+
+
+val ch_Rtpvfpvt = new Rtpvfpvt('a', 'b')
+val i_Rtpvfpvt = new Rtpvfpvt(1, 2)
+assert(2 == i_Rtpvfpvt.p2)
+assert('b' == ch_Rtpvfpvt.p2)
+
+
+val ch_Rtpvfvt = new Rtpvfvt('a', 'b')
+val i_Rtpvfvt = new Rtpvfvt(1, 2)
+assert(2 == i_Rtpvfvt.a)
+assert('b' == ch_Rtpvfvt.a)
+assert(2 == i_Rtpvfvt.p2)
+assert('b' == ch_Rtpvfvt.p2)
+
+
+val ch_Rtpvfnt = new Rtpvfnt('a', 'b')
+val i_Rtpvfnt = new Rtpvfnt(1, 2)
+assert(2 == i_Rtpvfnt.p2)
+assert('b' == ch_Rtpvfnt.p2)
+
+
+val ch_Rtvtpvt = new Rtvtpvt('a', 'b')
+val i_Rtvtpvt = new Rtvtpvt(1, 2)
+assert(1 == i_Rtvtpvt.`a b`)
+assert('a' == ch_Rtvtpvt.`a b`)
+assert(1 == i_Rtvtpvt.p1)
+assert(2 == i_Rtvtpvt.p2)
+assert('a' == ch_Rtvtpvt.p1)
+assert('b' == ch_Rtvtpvt.p2)
+
+
+val ch_Rtvtpvf = new Rtvtpvf('a', 'b')
+val i_Rtvtpvf = new Rtvtpvf(1, 2)
+assert(1 == i_Rtvtpvf.`a b`)
+assert('a' == ch_Rtvtpvf.`a b`)
+assert(1 == i_Rtvtpvf.p1)
+assert('a' == ch_Rtvtpvf.p1)
+
+
+val ch_Rtvtvt = new Rtvtvt('a', 'b')
+val i_Rtvtvt = new Rtvtvt(1, 2)
+assert(1 == i_Rtvtvt.`a b`)
+assert(2 == i_Rtvtvt.a)
+assert('a' == ch_Rtvtvt.`a b`)
+assert('b' == ch_Rtvtvt.a)
+assert(1 == i_Rtvtvt.p1)
+assert(2 == i_Rtvtvt.p2)
+assert('a' == ch_Rtvtvt.p1)
+assert('b' == ch_Rtvtvt.p2)
+
+
+val ch_Rtvtvf = new Rtvtvf('a', 'b')
+val i_Rtvtvf = new Rtvtvf(1, 2)
+assert(1 == i_Rtvtvf.`a b`)
+assert(2 == i_Rtvtvf.a)
+assert('a' == ch_Rtvtvf.`a b`)
+assert('b' == ch_Rtvtvf.a)
+assert(1 == i_Rtvtvf.p1)
+assert('a' == ch_Rtvtvf.p1)
+
+
+val ch_Rtvtnt = new Rtvtnt('a', 'b')
+val i_Rtvtnt = new Rtvtnt(1, 2)
+assert(1 == i_Rtvtnt.`a b`)
+assert('a' == ch_Rtvtnt.`a b`)
+assert(1 == i_Rtvtnt.p1)
+assert(2 == i_Rtvtnt.p2)
+assert('a' == ch_Rtvtnt.p1)
+assert('b' == ch_Rtvtnt.p2)
+
+
+val ch_Rtvtnf = new Rtvtnf('a', 'b')
+val i_Rtvtnf = new Rtvtnf(1, 2)
+assert(1 == i_Rtvtnf.`a b`)
+assert('a' == ch_Rtvtnf.`a b`)
+assert(1 == i_Rtvtnf.p1)
+assert('a' == ch_Rtvtnf.p1)
+
+
+val ch_Rtvfpvt = new Rtvfpvt('a', 'b')
+val i_Rtvfpvt = new Rtvfpvt(1, 2)
+assert(1 == i_Rtvfpvt.`a b`)
+assert('a' == ch_Rtvfpvt.`a b`)
+assert(2 == i_Rtvfpvt.p2)
+assert('b' == ch_Rtvfpvt.p2)
+
+
+val ch_Rtvfvt = new Rtvfvt('a', 'b')
+val i_Rtvfvt = new Rtvfvt(1, 2)
+assert(1 == i_Rtvfvt.`a b`)
+assert(2 == i_Rtvfvt.a)
+assert('a' == ch_Rtvfvt.`a b`)
+assert('b' == ch_Rtvfvt.a)
+assert(2 == i_Rtvfvt.p2)
+assert('b' == ch_Rtvfvt.p2)
+
+
+val ch_Rtvfnt = new Rtvfnt('a', 'b')
+val i_Rtvfnt = new Rtvfnt(1, 2)
+assert(1 == i_Rtvfnt.`a b`)
+assert('a' == ch_Rtvfnt.`a b`)
+assert(2 == i_Rtvfnt.p2)
+assert('b' == ch_Rtvfnt.p2)
+
+
+val ch_Rtntpvt = new Rtntpvt('a', 'b')
+val i_Rtntpvt = new Rtntpvt(1, 2)
+assert(1 == i_Rtntpvt.p1)
+assert(2 == i_Rtntpvt.p2)
+assert('a' == ch_Rtntpvt.p1)
+assert('b' == ch_Rtntpvt.p2)
+
+
+val ch_Rtntpvf = new Rtntpvf('a', 'b')
+val i_Rtntpvf = new Rtntpvf(1, 2)
+assert(1 == i_Rtntpvf.p1)
+assert('a' == ch_Rtntpvf.p1)
+
+
+val ch_Rtntvt = new Rtntvt('a', 'b')
+val i_Rtntvt = new Rtntvt(1, 2)
+assert(2 == i_Rtntvt.a)
+assert('b' == ch_Rtntvt.a)
+assert(1 == i_Rtntvt.p1)
+assert(2 == i_Rtntvt.p2)
+assert('a' == ch_Rtntvt.p1)
+assert('b' == ch_Rtntvt.p2)
+
+
+val ch_Rtntvf = new Rtntvf('a', 'b')
+val i_Rtntvf = new Rtntvf(1, 2)
+assert(2 == i_Rtntvf.a)
+assert('b' == ch_Rtntvf.a)
+assert(1 == i_Rtntvf.p1)
+assert('a' == ch_Rtntvf.p1)
+
+
+val ch_Rtntnt = new Rtntnt('a', 'b')
+val i_Rtntnt = new Rtntnt(1, 2)
+assert(1 == i_Rtntnt.p1)
+assert(2 == i_Rtntnt.p2)
+assert('a' == ch_Rtntnt.p1)
+assert('b' == ch_Rtntnt.p2)
+
+
+val ch_Rtntnf = new Rtntnf('a', 'b')
+val i_Rtntnf = new Rtntnf(1, 2)
+assert(1 == i_Rtntnf.p1)
+assert('a' == ch_Rtntnf.p1)
+
+
+val ch_Rtnfpvt = new Rtnfpvt('a', 'b')
+val i_Rtnfpvt = new Rtnfpvt(1, 2)
+assert(2 == i_Rtnfpvt.p2)
+assert('b' == ch_Rtnfpvt.p2)
+
+
+val ch_Rtnfvt = new Rtnfvt('a', 'b')
+val i_Rtnfvt = new Rtnfvt(1, 2)
+assert(2 == i_Rtnfvt.a)
+assert('b' == ch_Rtnfvt.a)
+assert(2 == i_Rtnfvt.p2)
+assert('b' == ch_Rtnfvt.p2)
+
+
+val ch_Rtnfnt = new Rtnfnt('a', 'b')
+val i_Rtnfnt = new Rtnfnt(1, 2)
+assert(2 == i_Rtnfnt.p2)
+assert('b' == ch_Rtnfnt.p2)
+
+
+val ch_Rfpvtpvt = new Rfpvtpvt('a', 'b')
+val i_Rfpvtpvt = new Rfpvtpvt(1, 2)
+assert(1 == i_Rfpvtpvt.p1)
+assert(2 == i_Rfpvtpvt.p2)
+assert('a' == ch_Rfpvtpvt.p1)
+assert('b' == ch_Rfpvtpvt.p2)
+
+
+val ch_Rfpvtpvf = new Rfpvtpvf('a', 'b')
+val i_Rfpvtpvf = new Rfpvtpvf(1, 2)
+assert(1 == i_Rfpvtpvf.p1)
+assert('a' == ch_Rfpvtpvf.p1)
+
+
+val ch_Rfpvtvt = new Rfpvtvt('a', 'b')
+val i_Rfpvtvt = new Rfpvtvt(1, 2)
+assert(2 == i_Rfpvtvt.a)
+assert('b' == ch_Rfpvtvt.a)
+assert(1 == i_Rfpvtvt.p1)
+assert(2 == i_Rfpvtvt.p2)
+assert('a' == ch_Rfpvtvt.p1)
+assert('b' == ch_Rfpvtvt.p2)
+
+
+val ch_Rfpvtvf = new Rfpvtvf('a', 'b')
+val i_Rfpvtvf = new Rfpvtvf(1, 2)
+assert(2 == i_Rfpvtvf.a)
+assert('b' == ch_Rfpvtvf.a)
+assert(1 == i_Rfpvtvf.p1)
+assert('a' == ch_Rfpvtvf.p1)
+
+
+val ch_Rfpvtnt = new Rfpvtnt('a', 'b')
+val i_Rfpvtnt = new Rfpvtnt(1, 2)
+assert(1 == i_Rfpvtnt.p1)
+assert(2 == i_Rfpvtnt.p2)
+assert('a' == ch_Rfpvtnt.p1)
+assert('b' == ch_Rfpvtnt.p2)
+
+
+val ch_Rfpvtnf = new Rfpvtnf('a', 'b')
+val i_Rfpvtnf = new Rfpvtnf(1, 2)
+assert(1 == i_Rfpvtnf.p1)
+assert('a' == ch_Rfpvtnf.p1)
+
+
+val ch_Rfpvfpvt = new Rfpvfpvt('a', 'b')
+val i_Rfpvfpvt = new Rfpvfpvt(1, 2)
+assert(2 == i_Rfpvfpvt.p2)
+assert('b' == ch_Rfpvfpvt.p2)
+
+
+val ch_Rfpvfpvf = new Rfpvfpvf('a', 'b')
+val i_Rfpvfpvf = new Rfpvfpvf(1, 2)
+
+
+val ch_Rfpvfvt = new Rfpvfvt('a', 'b')
+val i_Rfpvfvt = new Rfpvfvt(1, 2)
+assert(2 == i_Rfpvfvt.a)
+assert('b' == ch_Rfpvfvt.a)
+assert(2 == i_Rfpvfvt.p2)
+assert('b' == ch_Rfpvfvt.p2)
+
+
+val ch_Rfpvfvf = new Rfpvfvf('a', 'b')
+val i_Rfpvfvf = new Rfpvfvf(1, 2)
+assert(2 == i_Rfpvfvf.a)
+assert('b' == ch_Rfpvfvf.a)
+
+
+val ch_Rfpvfnt = new Rfpvfnt('a', 'b')
+val i_Rfpvfnt = new Rfpvfnt(1, 2)
+assert(2 == i_Rfpvfnt.p2)
+assert('b' == ch_Rfpvfnt.p2)
+
+
+val ch_Rfpvfnf = new Rfpvfnf('a', 'b')
+val i_Rfpvfnf = new Rfpvfnf(1, 2)
+
+
+val ch_Rfvtpvt = new Rfvtpvt('a', 'b')
+val i_Rfvtpvt = new Rfvtpvt(1, 2)
+assert(1 == i_Rfvtpvt.`a b`)
+assert('a' == ch_Rfvtpvt.`a b`)
+assert(1 == i_Rfvtpvt.p1)
+assert(2 == i_Rfvtpvt.p2)
+assert('a' == ch_Rfvtpvt.p1)
+assert('b' == ch_Rfvtpvt.p2)
+
+
+val ch_Rfvtpvf = new Rfvtpvf('a', 'b')
+val i_Rfvtpvf = new Rfvtpvf(1, 2)
+assert(1 == i_Rfvtpvf.`a b`)
+assert('a' == ch_Rfvtpvf.`a b`)
+assert(1 == i_Rfvtpvf.p1)
+assert('a' == ch_Rfvtpvf.p1)
+
+
+val ch_Rfvtvt = new Rfvtvt('a', 'b')
+val i_Rfvtvt = new Rfvtvt(1, 2)
+assert(1 == i_Rfvtvt.`a b`)
+assert(2 == i_Rfvtvt.a)
+assert('a' == ch_Rfvtvt.`a b`)
+assert('b' == ch_Rfvtvt.a)
+assert(1 == i_Rfvtvt.p1)
+assert(2 == i_Rfvtvt.p2)
+assert('a' == ch_Rfvtvt.p1)
+assert('b' == ch_Rfvtvt.p2)
+
+
+val ch_Rfvtvf = new Rfvtvf('a', 'b')
+val i_Rfvtvf = new Rfvtvf(1, 2)
+assert(1 == i_Rfvtvf.`a b`)
+assert(2 == i_Rfvtvf.a)
+assert('a' == ch_Rfvtvf.`a b`)
+assert('b' == ch_Rfvtvf.a)
+assert(1 == i_Rfvtvf.p1)
+assert('a' == ch_Rfvtvf.p1)
+
+
+val ch_Rfvtnt = new Rfvtnt('a', 'b')
+val i_Rfvtnt = new Rfvtnt(1, 2)
+assert(1 == i_Rfvtnt.`a b`)
+assert('a' == ch_Rfvtnt.`a b`)
+assert(1 == i_Rfvtnt.p1)
+assert(2 == i_Rfvtnt.p2)
+assert('a' == ch_Rfvtnt.p1)
+assert('b' == ch_Rfvtnt.p2)
+
+
+val ch_Rfvtnf = new Rfvtnf('a', 'b')
+val i_Rfvtnf = new Rfvtnf(1, 2)
+assert(1 == i_Rfvtnf.`a b`)
+assert('a' == ch_Rfvtnf.`a b`)
+assert(1 == i_Rfvtnf.p1)
+assert('a' == ch_Rfvtnf.p1)
+
+
+val ch_Rfvfpvt = new Rfvfpvt('a', 'b')
+val i_Rfvfpvt = new Rfvfpvt(1, 2)
+assert(1 == i_Rfvfpvt.`a b`)
+assert('a' == ch_Rfvfpvt.`a b`)
+assert(2 == i_Rfvfpvt.p2)
+assert('b' == ch_Rfvfpvt.p2)
+
+
+val ch_Rfvfpvf = new Rfvfpvf('a', 'b')
+val i_Rfvfpvf = new Rfvfpvf(1, 2)
+assert(1 == i_Rfvfpvf.`a b`)
+assert('a' == ch_Rfvfpvf.`a b`)
+
+
+val ch_Rfvfvt = new Rfvfvt('a', 'b')
+val i_Rfvfvt = new Rfvfvt(1, 2)
+assert(1 == i_Rfvfvt.`a b`)
+assert(2 == i_Rfvfvt.a)
+assert('a' == ch_Rfvfvt.`a b`)
+assert('b' == ch_Rfvfvt.a)
+assert(2 == i_Rfvfvt.p2)
+assert('b' == ch_Rfvfvt.p2)
+
+
+val ch_Rfvfvf = new Rfvfvf('a', 'b')
+val i_Rfvfvf = new Rfvfvf(1, 2)
+assert(1 == i_Rfvfvf.`a b`)
+assert(2 == i_Rfvfvf.a)
+assert('a' == ch_Rfvfvf.`a b`)
+assert('b' == ch_Rfvfvf.a)
+
+
+val ch_Rfvfnt = new Rfvfnt('a', 'b')
+val i_Rfvfnt = new Rfvfnt(1, 2)
+assert(1 == i_Rfvfnt.`a b`)
+assert('a' == ch_Rfvfnt.`a b`)
+assert(2 == i_Rfvfnt.p2)
+assert('b' == ch_Rfvfnt.p2)
+
+
+val ch_Rfvfnf = new Rfvfnf('a', 'b')
+val i_Rfvfnf = new Rfvfnf(1, 2)
+assert(1 == i_Rfvfnf.`a b`)
+assert('a' == ch_Rfvfnf.`a b`)
+
+
+val ch_Rfntpvt = new Rfntpvt('a', 'b')
+val i_Rfntpvt = new Rfntpvt(1, 2)
+assert(1 == i_Rfntpvt.p1)
+assert(2 == i_Rfntpvt.p2)
+assert('a' == ch_Rfntpvt.p1)
+assert('b' == ch_Rfntpvt.p2)
+
+
+val ch_Rfntpvf = new Rfntpvf('a', 'b')
+val i_Rfntpvf = new Rfntpvf(1, 2)
+assert(1 == i_Rfntpvf.p1)
+assert('a' == ch_Rfntpvf.p1)
+
+
+val ch_Rfntvt = new Rfntvt('a', 'b')
+val i_Rfntvt = new Rfntvt(1, 2)
+assert(2 == i_Rfntvt.a)
+assert('b' == ch_Rfntvt.a)
+assert(1 == i_Rfntvt.p1)
+assert(2 == i_Rfntvt.p2)
+assert('a' == ch_Rfntvt.p1)
+assert('b' == ch_Rfntvt.p2)
+
+
+val ch_Rfntvf = new Rfntvf('a', 'b')
+val i_Rfntvf = new Rfntvf(1, 2)
+assert(2 == i_Rfntvf.a)
+assert('b' == ch_Rfntvf.a)
+assert(1 == i_Rfntvf.p1)
+assert('a' == ch_Rfntvf.p1)
+
+
+val ch_Rfntnt = new Rfntnt('a', 'b')
+val i_Rfntnt = new Rfntnt(1, 2)
+assert(1 == i_Rfntnt.p1)
+assert(2 == i_Rfntnt.p2)
+assert('a' == ch_Rfntnt.p1)
+assert('b' == ch_Rfntnt.p2)
+
+
+val ch_Rfntnf = new Rfntnf('a', 'b')
+val i_Rfntnf = new Rfntnf(1, 2)
+assert(1 == i_Rfntnf.p1)
+assert('a' == ch_Rfntnf.p1)
+
+
+val ch_Rfnfpvt = new Rfnfpvt('a', 'b')
+val i_Rfnfpvt = new Rfnfpvt(1, 2)
+assert(2 == i_Rfnfpvt.p2)
+assert('b' == ch_Rfnfpvt.p2)
+
+
+val ch_Rfnfpvf = new Rfnfpvf('a', 'b')
+val i_Rfnfpvf = new Rfnfpvf(1, 2)
+
+
+val ch_Rfnfvt = new Rfnfvt('a', 'b')
+val i_Rfnfvt = new Rfnfvt(1, 2)
+assert(2 == i_Rfnfvt.a)
+assert('b' == ch_Rfnfvt.a)
+assert(2 == i_Rfnfvt.p2)
+assert('b' == ch_Rfnfvt.p2)
+
+
+val ch_Rfnfvf = new Rfnfvf('a', 'b')
+val i_Rfnfvf = new Rfnfvf(1, 2)
+assert(2 == i_Rfnfvf.a)
+assert('b' == ch_Rfnfvf.a)
+
+
+val ch_Rfnfnt = new Rfnfnt('a', 'b')
+val i_Rfnfnt = new Rfnfnt(1, 2)
+assert(2 == i_Rfnfnt.p2)
+assert('b' == ch_Rfnfnt.p2)
+
+
+val ch_Rfnfnf = new Rfnfnf('a', 'b')
+val i_Rfnfnf = new Rfnfnf(1, 2)
+
+
+}}
diff --git a/test/files/run/t8831_many/Tests_2.scala b/test/files/run/t8831_many/Tests_2.scala
new file mode 100644
index 000000000000..fba69ecabe56
--- /dev/null
+++ b/test/files/run/t8831_many/Tests_2.scala
@@ -0,0 +1,1488 @@
+object Test extends App {
+
+val ch_Ctpvtpvt = new Ctpvtpvt('a', 'b')
+val i_Ctpvtpvt = new Ctpvtpvt(1, 2)
+val Ctpvtpvt(extracted1i_Ctpvtpvt, extracted2i_Ctpvtpvt) = i_Ctpvtpvt
+val Ctpvtpvt(extracted1ch_Ctpvtpvt, extracted2ch_Ctpvtpvt) = ch_Ctpvtpvt
+assert(1 == extracted1i_Ctpvtpvt)
+assert(2 == extracted2i_Ctpvtpvt)
+assert('a' == extracted1ch_Ctpvtpvt)
+assert('b' == extracted2ch_Ctpvtpvt)
+
+assert(1 == i_Ctpvtpvt.p1)
+assert(2 == i_Ctpvtpvt.p2)
+assert('a' == ch_Ctpvtpvt.p1)
+assert('b' == ch_Ctpvtpvt.p2)
+
+
+val ch_Ctpvtpvf = new Ctpvtpvf('a', 'b')
+val i_Ctpvtpvf = new Ctpvtpvf(1, 2)
+val Ctpvtpvf(extracted1i_Ctpvtpvf, extracted2i_Ctpvtpvf) = i_Ctpvtpvf
+val Ctpvtpvf(extracted1ch_Ctpvtpvf, extracted2ch_Ctpvtpvf) = ch_Ctpvtpvf
+assert(1 == extracted1i_Ctpvtpvf)
+assert(2 == extracted2i_Ctpvtpvf)
+assert('a' == extracted1ch_Ctpvtpvf)
+assert('b' == extracted2ch_Ctpvtpvf)
+
+assert(1 == i_Ctpvtpvf.p1)
+assert('a' == ch_Ctpvtpvf.p1)
+
+
+val ch_Ctpvtvt = new Ctpvtvt('a', 'b')
+val i_Ctpvtvt = new Ctpvtvt(1, 2)
+val Ctpvtvt(extracted1i_Ctpvtvt, extracted2i_Ctpvtvt) = i_Ctpvtvt
+val Ctpvtvt(extracted1ch_Ctpvtvt, extracted2ch_Ctpvtvt) = ch_Ctpvtvt
+assert(1 == extracted1i_Ctpvtvt)
+assert(2 == extracted2i_Ctpvtvt)
+assert('a' == extracted1ch_Ctpvtvt)
+assert('b' == extracted2ch_Ctpvtvt)
+
+assert(2 == i_Ctpvtvt.a)
+assert('b' == ch_Ctpvtvt.a)
+assert(1 == i_Ctpvtvt.p1)
+assert(2 == i_Ctpvtvt.p2)
+assert('a' == ch_Ctpvtvt.p1)
+assert('b' == ch_Ctpvtvt.p2)
+
+
+val ch_Ctpvtvf = new Ctpvtvf('a', 'b')
+val i_Ctpvtvf = new Ctpvtvf(1, 2)
+val Ctpvtvf(extracted1i_Ctpvtvf, extracted2i_Ctpvtvf) = i_Ctpvtvf
+val Ctpvtvf(extracted1ch_Ctpvtvf, extracted2ch_Ctpvtvf) = ch_Ctpvtvf
+assert(1 == extracted1i_Ctpvtvf)
+assert(2 == extracted2i_Ctpvtvf)
+assert('a' == extracted1ch_Ctpvtvf)
+assert('b' == extracted2ch_Ctpvtvf)
+
+assert(2 == i_Ctpvtvf.a)
+assert('b' == ch_Ctpvtvf.a)
+assert(1 == i_Ctpvtvf.p1)
+assert('a' == ch_Ctpvtvf.p1)
+
+
+val ch_Ctpvtnt = new Ctpvtnt('a', 'b')
+val i_Ctpvtnt = new Ctpvtnt(1, 2)
+val Ctpvtnt(extracted1i_Ctpvtnt, extracted2i_Ctpvtnt) = i_Ctpvtnt
+val Ctpvtnt(extracted1ch_Ctpvtnt, extracted2ch_Ctpvtnt) = ch_Ctpvtnt
+assert(1 == extracted1i_Ctpvtnt)
+assert(2 == extracted2i_Ctpvtnt)
+assert('a' == extracted1ch_Ctpvtnt)
+assert('b' == extracted2ch_Ctpvtnt)
+
+assert(2 == i_Ctpvtnt.a)
+assert('b' == ch_Ctpvtnt.a)
+assert(1 == i_Ctpvtnt.p1)
+assert(2 == i_Ctpvtnt.p2)
+assert('a' == ch_Ctpvtnt.p1)
+assert('b' == ch_Ctpvtnt.p2)
+
+
+val ch_Ctpvtnf = new Ctpvtnf('a', 'b')
+val i_Ctpvtnf = new Ctpvtnf(1, 2)
+val Ctpvtnf(extracted1i_Ctpvtnf, extracted2i_Ctpvtnf) = i_Ctpvtnf
+val Ctpvtnf(extracted1ch_Ctpvtnf, extracted2ch_Ctpvtnf) = ch_Ctpvtnf
+assert(1 == extracted1i_Ctpvtnf)
+assert(2 == extracted2i_Ctpvtnf)
+assert('a' == extracted1ch_Ctpvtnf)
+assert('b' == extracted2ch_Ctpvtnf)
+
+assert(2 == i_Ctpvtnf.a)
+assert('b' == ch_Ctpvtnf.a)
+assert(1 == i_Ctpvtnf.p1)
+assert('a' == ch_Ctpvtnf.p1)
+
+
+val ch_Ctpvfpvt = new Ctpvfpvt('a', 'b')
+val i_Ctpvfpvt = new Ctpvfpvt(1, 2)
+val Ctpvfpvt(extracted1i_Ctpvfpvt, extracted2i_Ctpvfpvt) = i_Ctpvfpvt
+val Ctpvfpvt(extracted1ch_Ctpvfpvt, extracted2ch_Ctpvfpvt) = ch_Ctpvfpvt
+assert(1 == extracted1i_Ctpvfpvt)
+assert(2 == extracted2i_Ctpvfpvt)
+assert('a' == extracted1ch_Ctpvfpvt)
+assert('b' == extracted2ch_Ctpvfpvt)
+
+assert(2 == i_Ctpvfpvt.p2)
+assert('b' == ch_Ctpvfpvt.p2)
+
+
+val ch_Ctpvfvt = new Ctpvfvt('a', 'b')
+val i_Ctpvfvt = new Ctpvfvt(1, 2)
+val Ctpvfvt(extracted1i_Ctpvfvt, extracted2i_Ctpvfvt) = i_Ctpvfvt
+val Ctpvfvt(extracted1ch_Ctpvfvt, extracted2ch_Ctpvfvt) = ch_Ctpvfvt
+assert(1 == extracted1i_Ctpvfvt)
+assert(2 == extracted2i_Ctpvfvt)
+assert('a' == extracted1ch_Ctpvfvt)
+assert('b' == extracted2ch_Ctpvfvt)
+
+assert(2 == i_Ctpvfvt.a)
+assert('b' == ch_Ctpvfvt.a)
+assert(2 == i_Ctpvfvt.p2)
+assert('b' == ch_Ctpvfvt.p2)
+
+
+val ch_Ctpvfnt = new Ctpvfnt('a', 'b')
+val i_Ctpvfnt = new Ctpvfnt(1, 2)
+val Ctpvfnt(extracted1i_Ctpvfnt, extracted2i_Ctpvfnt) = i_Ctpvfnt
+val Ctpvfnt(extracted1ch_Ctpvfnt, extracted2ch_Ctpvfnt) = ch_Ctpvfnt
+assert(1 == extracted1i_Ctpvfnt)
+assert(2 == extracted2i_Ctpvfnt)
+assert('a' == extracted1ch_Ctpvfnt)
+assert('b' == extracted2ch_Ctpvfnt)
+
+assert(2 == i_Ctpvfnt.a)
+assert('b' == ch_Ctpvfnt.a)
+assert(2 == i_Ctpvfnt.p2)
+assert('b' == ch_Ctpvfnt.p2)
+
+
+val ch_Ctvtpvt = new Ctvtpvt('a', 'b')
+val i_Ctvtpvt = new Ctvtpvt(1, 2)
+val Ctvtpvt(extracted1i_Ctvtpvt, extracted2i_Ctvtpvt) = i_Ctvtpvt
+val Ctvtpvt(extracted1ch_Ctvtpvt, extracted2ch_Ctvtpvt) = ch_Ctvtpvt
+assert(1 == extracted1i_Ctvtpvt)
+assert(2 == extracted2i_Ctvtpvt)
+assert('a' == extracted1ch_Ctvtpvt)
+assert('b' == extracted2ch_Ctvtpvt)
+
+assert(1 == i_Ctvtpvt.`a b`)
+assert('a' == ch_Ctvtpvt.`a b`)
+assert(1 == i_Ctvtpvt.p1)
+assert(2 == i_Ctvtpvt.p2)
+assert('a' == ch_Ctvtpvt.p1)
+assert('b' == ch_Ctvtpvt.p2)
+
+
+val ch_Ctvtpvf = new Ctvtpvf('a', 'b')
+val i_Ctvtpvf = new Ctvtpvf(1, 2)
+val Ctvtpvf(extracted1i_Ctvtpvf, extracted2i_Ctvtpvf) = i_Ctvtpvf
+val Ctvtpvf(extracted1ch_Ctvtpvf, extracted2ch_Ctvtpvf) = ch_Ctvtpvf
+assert(1 == extracted1i_Ctvtpvf)
+assert(2 == extracted2i_Ctvtpvf)
+assert('a' == extracted1ch_Ctvtpvf)
+assert('b' == extracted2ch_Ctvtpvf)
+
+assert(1 == i_Ctvtpvf.`a b`)
+assert('a' == ch_Ctvtpvf.`a b`)
+assert(1 == i_Ctvtpvf.p1)
+assert('a' == ch_Ctvtpvf.p1)
+
+
+val ch_Ctvtvt = new Ctvtvt('a', 'b')
+val i_Ctvtvt = new Ctvtvt(1, 2)
+val Ctvtvt(extracted1i_Ctvtvt, extracted2i_Ctvtvt) = i_Ctvtvt
+val Ctvtvt(extracted1ch_Ctvtvt, extracted2ch_Ctvtvt) = ch_Ctvtvt
+assert(1 == extracted1i_Ctvtvt)
+assert(2 == extracted2i_Ctvtvt)
+assert('a' == extracted1ch_Ctvtvt)
+assert('b' == extracted2ch_Ctvtvt)
+
+assert(1 == i_Ctvtvt.`a b`)
+assert(2 == i_Ctvtvt.a)
+assert('a' == ch_Ctvtvt.`a b`)
+assert('b' == ch_Ctvtvt.a)
+assert(1 == i_Ctvtvt.p1)
+assert(2 == i_Ctvtvt.p2)
+assert('a' == ch_Ctvtvt.p1)
+assert('b' == ch_Ctvtvt.p2)
+
+
+val ch_Ctvtvf = new Ctvtvf('a', 'b')
+val i_Ctvtvf = new Ctvtvf(1, 2)
+val Ctvtvf(extracted1i_Ctvtvf, extracted2i_Ctvtvf) = i_Ctvtvf
+val Ctvtvf(extracted1ch_Ctvtvf, extracted2ch_Ctvtvf) = ch_Ctvtvf
+assert(1 == extracted1i_Ctvtvf)
+assert(2 == extracted2i_Ctvtvf)
+assert('a' == extracted1ch_Ctvtvf)
+assert('b' == extracted2ch_Ctvtvf)
+
+assert(1 == i_Ctvtvf.`a b`)
+assert(2 == i_Ctvtvf.a)
+assert('a' == ch_Ctvtvf.`a b`)
+assert('b' == ch_Ctvtvf.a)
+assert(1 == i_Ctvtvf.p1)
+assert('a' == ch_Ctvtvf.p1)
+
+
+val ch_Ctvtnt = new Ctvtnt('a', 'b')
+val i_Ctvtnt = new Ctvtnt(1, 2)
+val Ctvtnt(extracted1i_Ctvtnt, extracted2i_Ctvtnt) = i_Ctvtnt
+val Ctvtnt(extracted1ch_Ctvtnt, extracted2ch_Ctvtnt) = ch_Ctvtnt
+assert(1 == extracted1i_Ctvtnt)
+assert(2 == extracted2i_Ctvtnt)
+assert('a' == extracted1ch_Ctvtnt)
+assert('b' == extracted2ch_Ctvtnt)
+
+assert(1 == i_Ctvtnt.`a b`)
+assert(2 == i_Ctvtnt.a)
+assert('a' == ch_Ctvtnt.`a b`)
+assert('b' == ch_Ctvtnt.a)
+assert(1 == i_Ctvtnt.p1)
+assert(2 == i_Ctvtnt.p2)
+assert('a' == ch_Ctvtnt.p1)
+assert('b' == ch_Ctvtnt.p2)
+
+
+val ch_Ctvtnf = new Ctvtnf('a', 'b')
+val i_Ctvtnf = new Ctvtnf(1, 2)
+val Ctvtnf(extracted1i_Ctvtnf, extracted2i_Ctvtnf) = i_Ctvtnf
+val Ctvtnf(extracted1ch_Ctvtnf, extracted2ch_Ctvtnf) = ch_Ctvtnf
+assert(1 == extracted1i_Ctvtnf)
+assert(2 == extracted2i_Ctvtnf)
+assert('a' == extracted1ch_Ctvtnf)
+assert('b' == extracted2ch_Ctvtnf)
+
+assert(1 == i_Ctvtnf.`a b`)
+assert(2 == i_Ctvtnf.a)
+assert('a' == ch_Ctvtnf.`a b`)
+assert('b' == ch_Ctvtnf.a)
+assert(1 == i_Ctvtnf.p1)
+assert('a' == ch_Ctvtnf.p1)
+
+
+val ch_Ctvfpvt = new Ctvfpvt('a', 'b')
+val i_Ctvfpvt = new Ctvfpvt(1, 2)
+val Ctvfpvt(extracted1i_Ctvfpvt, extracted2i_Ctvfpvt) = i_Ctvfpvt
+val Ctvfpvt(extracted1ch_Ctvfpvt, extracted2ch_Ctvfpvt) = ch_Ctvfpvt
+assert(1 == extracted1i_Ctvfpvt)
+assert(2 == extracted2i_Ctvfpvt)
+assert('a' == extracted1ch_Ctvfpvt)
+assert('b' == extracted2ch_Ctvfpvt)
+
+assert(1 == i_Ctvfpvt.`a b`)
+assert('a' == ch_Ctvfpvt.`a b`)
+assert(2 == i_Ctvfpvt.p2)
+assert('b' == ch_Ctvfpvt.p2)
+
+
+val ch_Ctvfvt = new Ctvfvt('a', 'b')
+val i_Ctvfvt = new Ctvfvt(1, 2)
+val Ctvfvt(extracted1i_Ctvfvt, extracted2i_Ctvfvt) = i_Ctvfvt
+val Ctvfvt(extracted1ch_Ctvfvt, extracted2ch_Ctvfvt) = ch_Ctvfvt
+assert(1 == extracted1i_Ctvfvt)
+assert(2 == extracted2i_Ctvfvt)
+assert('a' == extracted1ch_Ctvfvt)
+assert('b' == extracted2ch_Ctvfvt)
+
+assert(1 == i_Ctvfvt.`a b`)
+assert(2 == i_Ctvfvt.a)
+assert('a' == ch_Ctvfvt.`a b`)
+assert('b' == ch_Ctvfvt.a)
+assert(2 == i_Ctvfvt.p2)
+assert('b' == ch_Ctvfvt.p2)
+
+
+val ch_Ctvfnt = new Ctvfnt('a', 'b')
+val i_Ctvfnt = new Ctvfnt(1, 2)
+val Ctvfnt(extracted1i_Ctvfnt, extracted2i_Ctvfnt) = i_Ctvfnt
+val Ctvfnt(extracted1ch_Ctvfnt, extracted2ch_Ctvfnt) = ch_Ctvfnt
+assert(1 == extracted1i_Ctvfnt)
+assert(2 == extracted2i_Ctvfnt)
+assert('a' == extracted1ch_Ctvfnt)
+assert('b' == extracted2ch_Ctvfnt)
+
+assert(1 == i_Ctvfnt.`a b`)
+assert(2 == i_Ctvfnt.a)
+assert('a' == ch_Ctvfnt.`a b`)
+assert('b' == ch_Ctvfnt.a)
+assert(2 == i_Ctvfnt.p2)
+assert('b' == ch_Ctvfnt.p2)
+
+
+val ch_Ctntpvt = new Ctntpvt('a', 'b')
+val i_Ctntpvt = new Ctntpvt(1, 2)
+val Ctntpvt(extracted1i_Ctntpvt, extracted2i_Ctntpvt) = i_Ctntpvt
+val Ctntpvt(extracted1ch_Ctntpvt, extracted2ch_Ctntpvt) = ch_Ctntpvt
+assert(1 == extracted1i_Ctntpvt)
+assert(2 == extracted2i_Ctntpvt)
+assert('a' == extracted1ch_Ctntpvt)
+assert('b' == extracted2ch_Ctntpvt)
+
+assert(1 == i_Ctntpvt.`a b`)
+assert('a' == ch_Ctntpvt.`a b`)
+assert(1 == i_Ctntpvt.p1)
+assert(2 == i_Ctntpvt.p2)
+assert('a' == ch_Ctntpvt.p1)
+assert('b' == ch_Ctntpvt.p2)
+
+
+val ch_Ctntpvf = new Ctntpvf('a', 'b')
+val i_Ctntpvf = new Ctntpvf(1, 2)
+val Ctntpvf(extracted1i_Ctntpvf, extracted2i_Ctntpvf) = i_Ctntpvf
+val Ctntpvf(extracted1ch_Ctntpvf, extracted2ch_Ctntpvf) = ch_Ctntpvf
+assert(1 == extracted1i_Ctntpvf)
+assert(2 == extracted2i_Ctntpvf)
+assert('a' == extracted1ch_Ctntpvf)
+assert('b' == extracted2ch_Ctntpvf)
+
+assert(1 == i_Ctntpvf.`a b`)
+assert('a' == ch_Ctntpvf.`a b`)
+assert(1 == i_Ctntpvf.p1)
+assert('a' == ch_Ctntpvf.p1)
+
+
+val ch_Ctntvt = new Ctntvt('a', 'b')
+val i_Ctntvt = new Ctntvt(1, 2)
+val Ctntvt(extracted1i_Ctntvt, extracted2i_Ctntvt) = i_Ctntvt
+val Ctntvt(extracted1ch_Ctntvt, extracted2ch_Ctntvt) = ch_Ctntvt
+assert(1 == extracted1i_Ctntvt)
+assert(2 == extracted2i_Ctntvt)
+assert('a' == extracted1ch_Ctntvt)
+assert('b' == extracted2ch_Ctntvt)
+
+assert(1 == i_Ctntvt.`a b`)
+assert(2 == i_Ctntvt.a)
+assert('a' == ch_Ctntvt.`a b`)
+assert('b' == ch_Ctntvt.a)
+assert(1 == i_Ctntvt.p1)
+assert(2 == i_Ctntvt.p2)
+assert('a' == ch_Ctntvt.p1)
+assert('b' == ch_Ctntvt.p2)
+
+
+val ch_Ctntvf = new Ctntvf('a', 'b')
+val i_Ctntvf = new Ctntvf(1, 2)
+val Ctntvf(extracted1i_Ctntvf, extracted2i_Ctntvf) = i_Ctntvf
+val Ctntvf(extracted1ch_Ctntvf, extracted2ch_Ctntvf) = ch_Ctntvf
+assert(1 == extracted1i_Ctntvf)
+assert(2 == extracted2i_Ctntvf)
+assert('a' == extracted1ch_Ctntvf)
+assert('b' == extracted2ch_Ctntvf)
+
+assert(1 == i_Ctntvf.`a b`)
+assert(2 == i_Ctntvf.a)
+assert('a' == ch_Ctntvf.`a b`)
+assert('b' == ch_Ctntvf.a)
+assert(1 == i_Ctntvf.p1)
+assert('a' == ch_Ctntvf.p1)
+
+
+val ch_Ctntnt = new Ctntnt('a', 'b')
+val i_Ctntnt = new Ctntnt(1, 2)
+val Ctntnt(extracted1i_Ctntnt, extracted2i_Ctntnt) = i_Ctntnt
+val Ctntnt(extracted1ch_Ctntnt, extracted2ch_Ctntnt) = ch_Ctntnt
+assert(1 == extracted1i_Ctntnt)
+assert(2 == extracted2i_Ctntnt)
+assert('a' == extracted1ch_Ctntnt)
+assert('b' == extracted2ch_Ctntnt)
+
+assert(1 == i_Ctntnt.`a b`)
+assert(2 == i_Ctntnt.a)
+assert('a' == ch_Ctntnt.`a b`)
+assert('b' == ch_Ctntnt.a)
+assert(1 == i_Ctntnt.p1)
+assert(2 == i_Ctntnt.p2)
+assert('a' == ch_Ctntnt.p1)
+assert('b' == ch_Ctntnt.p2)
+
+
+val ch_Ctntnf = new Ctntnf('a', 'b')
+val i_Ctntnf = new Ctntnf(1, 2)
+val Ctntnf(extracted1i_Ctntnf, extracted2i_Ctntnf) = i_Ctntnf
+val Ctntnf(extracted1ch_Ctntnf, extracted2ch_Ctntnf) = ch_Ctntnf
+assert(1 == extracted1i_Ctntnf)
+assert(2 == extracted2i_Ctntnf)
+assert('a' == extracted1ch_Ctntnf)
+assert('b' == extracted2ch_Ctntnf)
+
+assert(1 == i_Ctntnf.`a b`)
+assert(2 == i_Ctntnf.a)
+assert('a' == ch_Ctntnf.`a b`)
+assert('b' == ch_Ctntnf.a)
+assert(1 == i_Ctntnf.p1)
+assert('a' == ch_Ctntnf.p1)
+
+
+val ch_Ctnfpvt = new Ctnfpvt('a', 'b')
+val i_Ctnfpvt = new Ctnfpvt(1, 2)
+val Ctnfpvt(extracted1i_Ctnfpvt, extracted2i_Ctnfpvt) = i_Ctnfpvt
+val Ctnfpvt(extracted1ch_Ctnfpvt, extracted2ch_Ctnfpvt) = ch_Ctnfpvt
+assert(1 == extracted1i_Ctnfpvt)
+assert(2 == extracted2i_Ctnfpvt)
+assert('a' == extracted1ch_Ctnfpvt)
+assert('b' == extracted2ch_Ctnfpvt)
+
+assert(1 == i_Ctnfpvt.`a b`)
+assert('a' == ch_Ctnfpvt.`a b`)
+assert(2 == i_Ctnfpvt.p2)
+assert('b' == ch_Ctnfpvt.p2)
+
+
+val ch_Ctnfvt = new Ctnfvt('a', 'b')
+val i_Ctnfvt = new Ctnfvt(1, 2)
+val Ctnfvt(extracted1i_Ctnfvt, extracted2i_Ctnfvt) = i_Ctnfvt
+val Ctnfvt(extracted1ch_Ctnfvt, extracted2ch_Ctnfvt) = ch_Ctnfvt
+assert(1 == extracted1i_Ctnfvt)
+assert(2 == extracted2i_Ctnfvt)
+assert('a' == extracted1ch_Ctnfvt)
+assert('b' == extracted2ch_Ctnfvt)
+
+assert(1 == i_Ctnfvt.`a b`)
+assert(2 == i_Ctnfvt.a)
+assert('a' == ch_Ctnfvt.`a b`)
+assert('b' == ch_Ctnfvt.a)
+assert(2 == i_Ctnfvt.p2)
+assert('b' == ch_Ctnfvt.p2)
+
+
+val ch_Ctnfnt = new Ctnfnt('a', 'b')
+val i_Ctnfnt = new Ctnfnt(1, 2)
+val Ctnfnt(extracted1i_Ctnfnt, extracted2i_Ctnfnt) = i_Ctnfnt
+val Ctnfnt(extracted1ch_Ctnfnt, extracted2ch_Ctnfnt) = ch_Ctnfnt
+assert(1 == extracted1i_Ctnfnt)
+assert(2 == extracted2i_Ctnfnt)
+assert('a' == extracted1ch_Ctnfnt)
+assert('b' == extracted2ch_Ctnfnt)
+
+assert(1 == i_Ctnfnt.`a b`)
+assert(2 == i_Ctnfnt.a)
+assert('a' == ch_Ctnfnt.`a b`)
+assert('b' == ch_Ctnfnt.a)
+assert(2 == i_Ctnfnt.p2)
+assert('b' == ch_Ctnfnt.p2)
+
+
+val ch_Cfpvtpvt = new Cfpvtpvt('a', 'b')
+val i_Cfpvtpvt = new Cfpvtpvt(1, 2)
+val Cfpvtpvt(extracted1i_Cfpvtpvt, extracted2i_Cfpvtpvt) = i_Cfpvtpvt
+val Cfpvtpvt(extracted1ch_Cfpvtpvt, extracted2ch_Cfpvtpvt) = ch_Cfpvtpvt
+assert(1 == extracted1i_Cfpvtpvt)
+assert(2 == extracted2i_Cfpvtpvt)
+assert('a' == extracted1ch_Cfpvtpvt)
+assert('b' == extracted2ch_Cfpvtpvt)
+
+assert(1 == i_Cfpvtpvt.p1)
+assert(2 == i_Cfpvtpvt.p2)
+assert('a' == ch_Cfpvtpvt.p1)
+assert('b' == ch_Cfpvtpvt.p2)
+
+
+val ch_Cfpvtpvf = new Cfpvtpvf('a', 'b')
+val i_Cfpvtpvf = new Cfpvtpvf(1, 2)
+val Cfpvtpvf(extracted1i_Cfpvtpvf, extracted2i_Cfpvtpvf) = i_Cfpvtpvf
+val Cfpvtpvf(extracted1ch_Cfpvtpvf, extracted2ch_Cfpvtpvf) = ch_Cfpvtpvf
+assert(1 == extracted1i_Cfpvtpvf)
+assert(2 == extracted2i_Cfpvtpvf)
+assert('a' == extracted1ch_Cfpvtpvf)
+assert('b' == extracted2ch_Cfpvtpvf)
+
+assert(1 == i_Cfpvtpvf.p1)
+assert('a' == ch_Cfpvtpvf.p1)
+
+
+val ch_Cfpvtvt = new Cfpvtvt('a', 'b')
+val i_Cfpvtvt = new Cfpvtvt(1, 2)
+val Cfpvtvt(extracted1i_Cfpvtvt, extracted2i_Cfpvtvt) = i_Cfpvtvt
+val Cfpvtvt(extracted1ch_Cfpvtvt, extracted2ch_Cfpvtvt) = ch_Cfpvtvt
+assert(1 == extracted1i_Cfpvtvt)
+assert(2 == extracted2i_Cfpvtvt)
+assert('a' == extracted1ch_Cfpvtvt)
+assert('b' == extracted2ch_Cfpvtvt)
+
+assert(2 == i_Cfpvtvt.a)
+assert('b' == ch_Cfpvtvt.a)
+assert(1 == i_Cfpvtvt.p1)
+assert(2 == i_Cfpvtvt.p2)
+assert('a' == ch_Cfpvtvt.p1)
+assert('b' == ch_Cfpvtvt.p2)
+
+
+val ch_Cfpvtvf = new Cfpvtvf('a', 'b')
+val i_Cfpvtvf = new Cfpvtvf(1, 2)
+val Cfpvtvf(extracted1i_Cfpvtvf, extracted2i_Cfpvtvf) = i_Cfpvtvf
+val Cfpvtvf(extracted1ch_Cfpvtvf, extracted2ch_Cfpvtvf) = ch_Cfpvtvf
+assert(1 == extracted1i_Cfpvtvf)
+assert(2 == extracted2i_Cfpvtvf)
+assert('a' == extracted1ch_Cfpvtvf)
+assert('b' == extracted2ch_Cfpvtvf)
+
+assert(2 == i_Cfpvtvf.a)
+assert('b' == ch_Cfpvtvf.a)
+assert(1 == i_Cfpvtvf.p1)
+assert('a' == ch_Cfpvtvf.p1)
+
+
+val ch_Cfpvtnt = new Cfpvtnt('a', 'b')
+val i_Cfpvtnt = new Cfpvtnt(1, 2)
+val Cfpvtnt(extracted1i_Cfpvtnt, extracted2i_Cfpvtnt) = i_Cfpvtnt
+val Cfpvtnt(extracted1ch_Cfpvtnt, extracted2ch_Cfpvtnt) = ch_Cfpvtnt
+assert(1 == extracted1i_Cfpvtnt)
+assert(2 == extracted2i_Cfpvtnt)
+assert('a' == extracted1ch_Cfpvtnt)
+assert('b' == extracted2ch_Cfpvtnt)
+
+assert(2 == i_Cfpvtnt.a)
+assert('b' == ch_Cfpvtnt.a)
+assert(1 == i_Cfpvtnt.p1)
+assert(2 == i_Cfpvtnt.p2)
+assert('a' == ch_Cfpvtnt.p1)
+assert('b' == ch_Cfpvtnt.p2)
+
+
+val ch_Cfpvtnf = new Cfpvtnf('a', 'b')
+val i_Cfpvtnf = new Cfpvtnf(1, 2)
+val Cfpvtnf(extracted1i_Cfpvtnf, extracted2i_Cfpvtnf) = i_Cfpvtnf
+val Cfpvtnf(extracted1ch_Cfpvtnf, extracted2ch_Cfpvtnf) = ch_Cfpvtnf
+assert(1 == extracted1i_Cfpvtnf)
+assert(2 == extracted2i_Cfpvtnf)
+assert('a' == extracted1ch_Cfpvtnf)
+assert('b' == extracted2ch_Cfpvtnf)
+
+assert(2 == i_Cfpvtnf.a)
+assert('b' == ch_Cfpvtnf.a)
+assert(1 == i_Cfpvtnf.p1)
+assert('a' == ch_Cfpvtnf.p1)
+
+
+val ch_Cfpvfpvt = new Cfpvfpvt('a', 'b')
+val i_Cfpvfpvt = new Cfpvfpvt(1, 2)
+val Cfpvfpvt(extracted1i_Cfpvfpvt, extracted2i_Cfpvfpvt) = i_Cfpvfpvt
+val Cfpvfpvt(extracted1ch_Cfpvfpvt, extracted2ch_Cfpvfpvt) = ch_Cfpvfpvt
+assert(1 == extracted1i_Cfpvfpvt)
+assert(2 == extracted2i_Cfpvfpvt)
+assert('a' == extracted1ch_Cfpvfpvt)
+assert('b' == extracted2ch_Cfpvfpvt)
+
+assert(2 == i_Cfpvfpvt.p2)
+assert('b' == ch_Cfpvfpvt.p2)
+
+
+val ch_Cfpvfpvf = new Cfpvfpvf('a', 'b')
+val i_Cfpvfpvf = new Cfpvfpvf(1, 2)
+val Cfpvfpvf(extracted1i_Cfpvfpvf, extracted2i_Cfpvfpvf) = i_Cfpvfpvf
+val Cfpvfpvf(extracted1ch_Cfpvfpvf, extracted2ch_Cfpvfpvf) = ch_Cfpvfpvf
+assert(1 == extracted1i_Cfpvfpvf)
+assert(2 == extracted2i_Cfpvfpvf)
+assert('a' == extracted1ch_Cfpvfpvf)
+assert('b' == extracted2ch_Cfpvfpvf)
+
+
+
+val ch_Cfpvfvt = new Cfpvfvt('a', 'b')
+val i_Cfpvfvt = new Cfpvfvt(1, 2)
+val Cfpvfvt(extracted1i_Cfpvfvt, extracted2i_Cfpvfvt) = i_Cfpvfvt
+val Cfpvfvt(extracted1ch_Cfpvfvt, extracted2ch_Cfpvfvt) = ch_Cfpvfvt
+assert(1 == extracted1i_Cfpvfvt)
+assert(2 == extracted2i_Cfpvfvt)
+assert('a' == extracted1ch_Cfpvfvt)
+assert('b' == extracted2ch_Cfpvfvt)
+
+assert(2 == i_Cfpvfvt.a)
+assert('b' == ch_Cfpvfvt.a)
+assert(2 == i_Cfpvfvt.p2)
+assert('b' == ch_Cfpvfvt.p2)
+
+
+val ch_Cfpvfvf = new Cfpvfvf('a', 'b')
+val i_Cfpvfvf = new Cfpvfvf(1, 2)
+val Cfpvfvf(extracted1i_Cfpvfvf, extracted2i_Cfpvfvf) = i_Cfpvfvf
+val Cfpvfvf(extracted1ch_Cfpvfvf, extracted2ch_Cfpvfvf) = ch_Cfpvfvf
+assert(1 == extracted1i_Cfpvfvf)
+assert(2 == extracted2i_Cfpvfvf)
+assert('a' == extracted1ch_Cfpvfvf)
+assert('b' == extracted2ch_Cfpvfvf)
+
+assert(2 == i_Cfpvfvf.a)
+assert('b' == ch_Cfpvfvf.a)
+
+
+val ch_Cfpvfnt = new Cfpvfnt('a', 'b')
+val i_Cfpvfnt = new Cfpvfnt(1, 2)
+val Cfpvfnt(extracted1i_Cfpvfnt, extracted2i_Cfpvfnt) = i_Cfpvfnt
+val Cfpvfnt(extracted1ch_Cfpvfnt, extracted2ch_Cfpvfnt) = ch_Cfpvfnt
+assert(1 == extracted1i_Cfpvfnt)
+assert(2 == extracted2i_Cfpvfnt)
+assert('a' == extracted1ch_Cfpvfnt)
+assert('b' == extracted2ch_Cfpvfnt)
+
+assert(2 == i_Cfpvfnt.a)
+assert('b' == ch_Cfpvfnt.a)
+assert(2 == i_Cfpvfnt.p2)
+assert('b' == ch_Cfpvfnt.p2)
+
+
+val ch_Cfpvfnf = new Cfpvfnf('a', 'b')
+val i_Cfpvfnf = new Cfpvfnf(1, 2)
+val Cfpvfnf(extracted1i_Cfpvfnf, extracted2i_Cfpvfnf) = i_Cfpvfnf
+val Cfpvfnf(extracted1ch_Cfpvfnf, extracted2ch_Cfpvfnf) = ch_Cfpvfnf
+assert(1 == extracted1i_Cfpvfnf)
+assert(2 == extracted2i_Cfpvfnf)
+assert('a' == extracted1ch_Cfpvfnf)
+assert('b' == extracted2ch_Cfpvfnf)
+
+assert(2 == i_Cfpvfnf.a)
+assert('b' == ch_Cfpvfnf.a)
+
+
+val ch_Cfvtpvt = new Cfvtpvt('a', 'b')
+val i_Cfvtpvt = new Cfvtpvt(1, 2)
+val Cfvtpvt(extracted1i_Cfvtpvt, extracted2i_Cfvtpvt) = i_Cfvtpvt
+val Cfvtpvt(extracted1ch_Cfvtpvt, extracted2ch_Cfvtpvt) = ch_Cfvtpvt
+assert(1 == extracted1i_Cfvtpvt)
+assert(2 == extracted2i_Cfvtpvt)
+assert('a' == extracted1ch_Cfvtpvt)
+assert('b' == extracted2ch_Cfvtpvt)
+
+assert(1 == i_Cfvtpvt.`a b`)
+assert('a' == ch_Cfvtpvt.`a b`)
+assert(1 == i_Cfvtpvt.p1)
+assert(2 == i_Cfvtpvt.p2)
+assert('a' == ch_Cfvtpvt.p1)
+assert('b' == ch_Cfvtpvt.p2)
+
+
+val ch_Cfvtpvf = new Cfvtpvf('a', 'b')
+val i_Cfvtpvf = new Cfvtpvf(1, 2)
+val Cfvtpvf(extracted1i_Cfvtpvf, extracted2i_Cfvtpvf) = i_Cfvtpvf
+val Cfvtpvf(extracted1ch_Cfvtpvf, extracted2ch_Cfvtpvf) = ch_Cfvtpvf
+assert(1 == extracted1i_Cfvtpvf)
+assert(2 == extracted2i_Cfvtpvf)
+assert('a' == extracted1ch_Cfvtpvf)
+assert('b' == extracted2ch_Cfvtpvf)
+
+assert(1 == i_Cfvtpvf.`a b`)
+assert('a' == ch_Cfvtpvf.`a b`)
+assert(1 == i_Cfvtpvf.p1)
+assert('a' == ch_Cfvtpvf.p1)
+
+
+val ch_Cfvtvt = new Cfvtvt('a', 'b')
+val i_Cfvtvt = new Cfvtvt(1, 2)
+val Cfvtvt(extracted1i_Cfvtvt, extracted2i_Cfvtvt) = i_Cfvtvt
+val Cfvtvt(extracted1ch_Cfvtvt, extracted2ch_Cfvtvt) = ch_Cfvtvt
+assert(1 == extracted1i_Cfvtvt)
+assert(2 == extracted2i_Cfvtvt)
+assert('a' == extracted1ch_Cfvtvt)
+assert('b' == extracted2ch_Cfvtvt)
+
+assert(1 == i_Cfvtvt.`a b`)
+assert(2 == i_Cfvtvt.a)
+assert('a' == ch_Cfvtvt.`a b`)
+assert('b' == ch_Cfvtvt.a)
+assert(1 == i_Cfvtvt.p1)
+assert(2 == i_Cfvtvt.p2)
+assert('a' == ch_Cfvtvt.p1)
+assert('b' == ch_Cfvtvt.p2)
+
+
+val ch_Cfvtvf = new Cfvtvf('a', 'b')
+val i_Cfvtvf = new Cfvtvf(1, 2)
+val Cfvtvf(extracted1i_Cfvtvf, extracted2i_Cfvtvf) = i_Cfvtvf
+val Cfvtvf(extracted1ch_Cfvtvf, extracted2ch_Cfvtvf) = ch_Cfvtvf
+assert(1 == extracted1i_Cfvtvf)
+assert(2 == extracted2i_Cfvtvf)
+assert('a' == extracted1ch_Cfvtvf)
+assert('b' == extracted2ch_Cfvtvf)
+
+assert(1 == i_Cfvtvf.`a b`)
+assert(2 == i_Cfvtvf.a)
+assert('a' == ch_Cfvtvf.`a b`)
+assert('b' == ch_Cfvtvf.a)
+assert(1 == i_Cfvtvf.p1)
+assert('a' == ch_Cfvtvf.p1)
+
+
+val ch_Cfvtnt = new Cfvtnt('a', 'b')
+val i_Cfvtnt = new Cfvtnt(1, 2)
+val Cfvtnt(extracted1i_Cfvtnt, extracted2i_Cfvtnt) = i_Cfvtnt
+val Cfvtnt(extracted1ch_Cfvtnt, extracted2ch_Cfvtnt) = ch_Cfvtnt
+assert(1 == extracted1i_Cfvtnt)
+assert(2 == extracted2i_Cfvtnt)
+assert('a' == extracted1ch_Cfvtnt)
+assert('b' == extracted2ch_Cfvtnt)
+
+assert(1 == i_Cfvtnt.`a b`)
+assert(2 == i_Cfvtnt.a)
+assert('a' == ch_Cfvtnt.`a b`)
+assert('b' == ch_Cfvtnt.a)
+assert(1 == i_Cfvtnt.p1)
+assert(2 == i_Cfvtnt.p2)
+assert('a' == ch_Cfvtnt.p1)
+assert('b' == ch_Cfvtnt.p2)
+
+
+val ch_Cfvtnf = new Cfvtnf('a', 'b')
+val i_Cfvtnf = new Cfvtnf(1, 2)
+val Cfvtnf(extracted1i_Cfvtnf, extracted2i_Cfvtnf) = i_Cfvtnf
+val Cfvtnf(extracted1ch_Cfvtnf, extracted2ch_Cfvtnf) = ch_Cfvtnf
+assert(1 == extracted1i_Cfvtnf)
+assert(2 == extracted2i_Cfvtnf)
+assert('a' == extracted1ch_Cfvtnf)
+assert('b' == extracted2ch_Cfvtnf)
+
+assert(1 == i_Cfvtnf.`a b`)
+assert(2 == i_Cfvtnf.a)
+assert('a' == ch_Cfvtnf.`a b`)
+assert('b' == ch_Cfvtnf.a)
+assert(1 == i_Cfvtnf.p1)
+assert('a' == ch_Cfvtnf.p1)
+
+
+val ch_Cfvfpvt = new Cfvfpvt('a', 'b')
+val i_Cfvfpvt = new Cfvfpvt(1, 2)
+val Cfvfpvt(extracted1i_Cfvfpvt, extracted2i_Cfvfpvt) = i_Cfvfpvt
+val Cfvfpvt(extracted1ch_Cfvfpvt, extracted2ch_Cfvfpvt) = ch_Cfvfpvt
+assert(1 == extracted1i_Cfvfpvt)
+assert(2 == extracted2i_Cfvfpvt)
+assert('a' == extracted1ch_Cfvfpvt)
+assert('b' == extracted2ch_Cfvfpvt)
+
+assert(1 == i_Cfvfpvt.`a b`)
+assert('a' == ch_Cfvfpvt.`a b`)
+assert(2 == i_Cfvfpvt.p2)
+assert('b' == ch_Cfvfpvt.p2)
+
+
+val ch_Cfvfpvf = new Cfvfpvf('a', 'b')
+val i_Cfvfpvf = new Cfvfpvf(1, 2)
+val Cfvfpvf(extracted1i_Cfvfpvf, extracted2i_Cfvfpvf) = i_Cfvfpvf
+val Cfvfpvf(extracted1ch_Cfvfpvf, extracted2ch_Cfvfpvf) = ch_Cfvfpvf
+assert(1 == extracted1i_Cfvfpvf)
+assert(2 == extracted2i_Cfvfpvf)
+assert('a' == extracted1ch_Cfvfpvf)
+assert('b' == extracted2ch_Cfvfpvf)
+
+assert(1 == i_Cfvfpvf.`a b`)
+assert('a' == ch_Cfvfpvf.`a b`)
+
+
+val ch_Cfvfvt = new Cfvfvt('a', 'b')
+val i_Cfvfvt = new Cfvfvt(1, 2)
+val Cfvfvt(extracted1i_Cfvfvt, extracted2i_Cfvfvt) = i_Cfvfvt
+val Cfvfvt(extracted1ch_Cfvfvt, extracted2ch_Cfvfvt) = ch_Cfvfvt
+assert(1 == extracted1i_Cfvfvt)
+assert(2 == extracted2i_Cfvfvt)
+assert('a' == extracted1ch_Cfvfvt)
+assert('b' == extracted2ch_Cfvfvt)
+
+assert(1 == i_Cfvfvt.`a b`)
+assert(2 == i_Cfvfvt.a)
+assert('a' == ch_Cfvfvt.`a b`)
+assert('b' == ch_Cfvfvt.a)
+assert(2 == i_Cfvfvt.p2)
+assert('b' == ch_Cfvfvt.p2)
+
+
+val ch_Cfvfvf = new Cfvfvf('a', 'b')
+val i_Cfvfvf = new Cfvfvf(1, 2)
+val Cfvfvf(extracted1i_Cfvfvf, extracted2i_Cfvfvf) = i_Cfvfvf
+val Cfvfvf(extracted1ch_Cfvfvf, extracted2ch_Cfvfvf) = ch_Cfvfvf
+assert(1 == extracted1i_Cfvfvf)
+assert(2 == extracted2i_Cfvfvf)
+assert('a' == extracted1ch_Cfvfvf)
+assert('b' == extracted2ch_Cfvfvf)
+
+assert(1 == i_Cfvfvf.`a b`)
+assert(2 == i_Cfvfvf.a)
+assert('a' == ch_Cfvfvf.`a b`)
+assert('b' == ch_Cfvfvf.a)
+
+
+val ch_Cfvfnt = new Cfvfnt('a', 'b')
+val i_Cfvfnt = new Cfvfnt(1, 2)
+val Cfvfnt(extracted1i_Cfvfnt, extracted2i_Cfvfnt) = i_Cfvfnt
+val Cfvfnt(extracted1ch_Cfvfnt, extracted2ch_Cfvfnt) = ch_Cfvfnt
+assert(1 == extracted1i_Cfvfnt)
+assert(2 == extracted2i_Cfvfnt)
+assert('a' == extracted1ch_Cfvfnt)
+assert('b' == extracted2ch_Cfvfnt)
+
+assert(1 == i_Cfvfnt.`a b`)
+assert(2 == i_Cfvfnt.a)
+assert('a' == ch_Cfvfnt.`a b`)
+assert('b' == ch_Cfvfnt.a)
+assert(2 == i_Cfvfnt.p2)
+assert('b' == ch_Cfvfnt.p2)
+
+
+val ch_Cfvfnf = new Cfvfnf('a', 'b')
+val i_Cfvfnf = new Cfvfnf(1, 2)
+val Cfvfnf(extracted1i_Cfvfnf, extracted2i_Cfvfnf) = i_Cfvfnf
+val Cfvfnf(extracted1ch_Cfvfnf, extracted2ch_Cfvfnf) = ch_Cfvfnf
+assert(1 == extracted1i_Cfvfnf)
+assert(2 == extracted2i_Cfvfnf)
+assert('a' == extracted1ch_Cfvfnf)
+assert('b' == extracted2ch_Cfvfnf)
+
+assert(1 == i_Cfvfnf.`a b`)
+assert(2 == i_Cfvfnf.a)
+assert('a' == ch_Cfvfnf.`a b`)
+assert('b' == ch_Cfvfnf.a)
+
+
+val ch_Cfntpvt = new Cfntpvt('a', 'b')
+val i_Cfntpvt = new Cfntpvt(1, 2)
+val Cfntpvt(extracted1i_Cfntpvt, extracted2i_Cfntpvt) = i_Cfntpvt
+val Cfntpvt(extracted1ch_Cfntpvt, extracted2ch_Cfntpvt) = ch_Cfntpvt
+assert(1 == extracted1i_Cfntpvt)
+assert(2 == extracted2i_Cfntpvt)
+assert('a' == extracted1ch_Cfntpvt)
+assert('b' == extracted2ch_Cfntpvt)
+
+assert(1 == i_Cfntpvt.`a b`)
+assert('a' == ch_Cfntpvt.`a b`)
+assert(1 == i_Cfntpvt.p1)
+assert(2 == i_Cfntpvt.p2)
+assert('a' == ch_Cfntpvt.p1)
+assert('b' == ch_Cfntpvt.p2)
+
+
+val ch_Cfntpvf = new Cfntpvf('a', 'b')
+val i_Cfntpvf = new Cfntpvf(1, 2)
+val Cfntpvf(extracted1i_Cfntpvf, extracted2i_Cfntpvf) = i_Cfntpvf
+val Cfntpvf(extracted1ch_Cfntpvf, extracted2ch_Cfntpvf) = ch_Cfntpvf
+assert(1 == extracted1i_Cfntpvf)
+assert(2 == extracted2i_Cfntpvf)
+assert('a' == extracted1ch_Cfntpvf)
+assert('b' == extracted2ch_Cfntpvf)
+
+assert(1 == i_Cfntpvf.`a b`)
+assert('a' == ch_Cfntpvf.`a b`)
+assert(1 == i_Cfntpvf.p1)
+assert('a' == ch_Cfntpvf.p1)
+
+
+val ch_Cfntvt = new Cfntvt('a', 'b')
+val i_Cfntvt = new Cfntvt(1, 2)
+val Cfntvt(extracted1i_Cfntvt, extracted2i_Cfntvt) = i_Cfntvt
+val Cfntvt(extracted1ch_Cfntvt, extracted2ch_Cfntvt) = ch_Cfntvt
+assert(1 == extracted1i_Cfntvt)
+assert(2 == extracted2i_Cfntvt)
+assert('a' == extracted1ch_Cfntvt)
+assert('b' == extracted2ch_Cfntvt)
+
+assert(1 == i_Cfntvt.`a b`)
+assert(2 == i_Cfntvt.a)
+assert('a' == ch_Cfntvt.`a b`)
+assert('b' == ch_Cfntvt.a)
+assert(1 == i_Cfntvt.p1)
+assert(2 == i_Cfntvt.p2)
+assert('a' == ch_Cfntvt.p1)
+assert('b' == ch_Cfntvt.p2)
+
+
+val ch_Cfntvf = new Cfntvf('a', 'b')
+val i_Cfntvf = new Cfntvf(1, 2)
+val Cfntvf(extracted1i_Cfntvf, extracted2i_Cfntvf) = i_Cfntvf
+val Cfntvf(extracted1ch_Cfntvf, extracted2ch_Cfntvf) = ch_Cfntvf
+assert(1 == extracted1i_Cfntvf)
+assert(2 == extracted2i_Cfntvf)
+assert('a' == extracted1ch_Cfntvf)
+assert('b' == extracted2ch_Cfntvf)
+
+assert(1 == i_Cfntvf.`a b`)
+assert(2 == i_Cfntvf.a)
+assert('a' == ch_Cfntvf.`a b`)
+assert('b' == ch_Cfntvf.a)
+assert(1 == i_Cfntvf.p1)
+assert('a' == ch_Cfntvf.p1)
+
+
+val ch_Cfntnt = new Cfntnt('a', 'b')
+val i_Cfntnt = new Cfntnt(1, 2)
+val Cfntnt(extracted1i_Cfntnt, extracted2i_Cfntnt) = i_Cfntnt
+val Cfntnt(extracted1ch_Cfntnt, extracted2ch_Cfntnt) = ch_Cfntnt
+assert(1 == extracted1i_Cfntnt)
+assert(2 == extracted2i_Cfntnt)
+assert('a' == extracted1ch_Cfntnt)
+assert('b' == extracted2ch_Cfntnt)
+
+assert(1 == i_Cfntnt.`a b`)
+assert(2 == i_Cfntnt.a)
+assert('a' == ch_Cfntnt.`a b`)
+assert('b' == ch_Cfntnt.a)
+assert(1 == i_Cfntnt.p1)
+assert(2 == i_Cfntnt.p2)
+assert('a' == ch_Cfntnt.p1)
+assert('b' == ch_Cfntnt.p2)
+
+
+val ch_Cfntnf = new Cfntnf('a', 'b')
+val i_Cfntnf = new Cfntnf(1, 2)
+val Cfntnf(extracted1i_Cfntnf, extracted2i_Cfntnf) = i_Cfntnf
+val Cfntnf(extracted1ch_Cfntnf, extracted2ch_Cfntnf) = ch_Cfntnf
+assert(1 == extracted1i_Cfntnf)
+assert(2 == extracted2i_Cfntnf)
+assert('a' == extracted1ch_Cfntnf)
+assert('b' == extracted2ch_Cfntnf)
+
+assert(1 == i_Cfntnf.`a b`)
+assert(2 == i_Cfntnf.a)
+assert('a' == ch_Cfntnf.`a b`)
+assert('b' == ch_Cfntnf.a)
+assert(1 == i_Cfntnf.p1)
+assert('a' == ch_Cfntnf.p1)
+
+
+val ch_Cfnfpvt = new Cfnfpvt('a', 'b')
+val i_Cfnfpvt = new Cfnfpvt(1, 2)
+val Cfnfpvt(extracted1i_Cfnfpvt, extracted2i_Cfnfpvt) = i_Cfnfpvt
+val Cfnfpvt(extracted1ch_Cfnfpvt, extracted2ch_Cfnfpvt) = ch_Cfnfpvt
+assert(1 == extracted1i_Cfnfpvt)
+assert(2 == extracted2i_Cfnfpvt)
+assert('a' == extracted1ch_Cfnfpvt)
+assert('b' == extracted2ch_Cfnfpvt)
+
+assert(1 == i_Cfnfpvt.`a b`)
+assert('a' == ch_Cfnfpvt.`a b`)
+assert(2 == i_Cfnfpvt.p2)
+assert('b' == ch_Cfnfpvt.p2)
+
+
+val ch_Cfnfpvf = new Cfnfpvf('a', 'b')
+val i_Cfnfpvf = new Cfnfpvf(1, 2)
+val Cfnfpvf(extracted1i_Cfnfpvf, extracted2i_Cfnfpvf) = i_Cfnfpvf
+val Cfnfpvf(extracted1ch_Cfnfpvf, extracted2ch_Cfnfpvf) = ch_Cfnfpvf
+assert(1 == extracted1i_Cfnfpvf)
+assert(2 == extracted2i_Cfnfpvf)
+assert('a' == extracted1ch_Cfnfpvf)
+assert('b' == extracted2ch_Cfnfpvf)
+
+assert(1 == i_Cfnfpvf.`a b`)
+assert('a' == ch_Cfnfpvf.`a b`)
+
+
+val ch_Cfnfvt = new Cfnfvt('a', 'b')
+val i_Cfnfvt = new Cfnfvt(1, 2)
+val Cfnfvt(extracted1i_Cfnfvt, extracted2i_Cfnfvt) = i_Cfnfvt
+val Cfnfvt(extracted1ch_Cfnfvt, extracted2ch_Cfnfvt) = ch_Cfnfvt
+assert(1 == extracted1i_Cfnfvt)
+assert(2 == extracted2i_Cfnfvt)
+assert('a' == extracted1ch_Cfnfvt)
+assert('b' == extracted2ch_Cfnfvt)
+
+assert(1 == i_Cfnfvt.`a b`)
+assert(2 == i_Cfnfvt.a)
+assert('a' == ch_Cfnfvt.`a b`)
+assert('b' == ch_Cfnfvt.a)
+assert(2 == i_Cfnfvt.p2)
+assert('b' == ch_Cfnfvt.p2)
+
+
+val ch_Cfnfvf = new Cfnfvf('a', 'b')
+val i_Cfnfvf = new Cfnfvf(1, 2)
+val Cfnfvf(extracted1i_Cfnfvf, extracted2i_Cfnfvf) = i_Cfnfvf
+val Cfnfvf(extracted1ch_Cfnfvf, extracted2ch_Cfnfvf) = ch_Cfnfvf
+assert(1 == extracted1i_Cfnfvf)
+assert(2 == extracted2i_Cfnfvf)
+assert('a' == extracted1ch_Cfnfvf)
+assert('b' == extracted2ch_Cfnfvf)
+
+assert(1 == i_Cfnfvf.`a b`)
+assert(2 == i_Cfnfvf.a)
+assert('a' == ch_Cfnfvf.`a b`)
+assert('b' == ch_Cfnfvf.a)
+
+
+val ch_Cfnfnt = new Cfnfnt('a', 'b')
+val i_Cfnfnt = new Cfnfnt(1, 2)
+val Cfnfnt(extracted1i_Cfnfnt, extracted2i_Cfnfnt) = i_Cfnfnt
+val Cfnfnt(extracted1ch_Cfnfnt, extracted2ch_Cfnfnt) = ch_Cfnfnt
+assert(1 == extracted1i_Cfnfnt)
+assert(2 == extracted2i_Cfnfnt)
+assert('a' == extracted1ch_Cfnfnt)
+assert('b' == extracted2ch_Cfnfnt)
+
+assert(1 == i_Cfnfnt.`a b`)
+assert(2 == i_Cfnfnt.a)
+assert('a' == ch_Cfnfnt.`a b`)
+assert('b' == ch_Cfnfnt.a)
+assert(2 == i_Cfnfnt.p2)
+assert('b' == ch_Cfnfnt.p2)
+
+
+val ch_Cfnfnf = new Cfnfnf('a', 'b')
+val i_Cfnfnf = new Cfnfnf(1, 2)
+val Cfnfnf(extracted1i_Cfnfnf, extracted2i_Cfnfnf) = i_Cfnfnf
+val Cfnfnf(extracted1ch_Cfnfnf, extracted2ch_Cfnfnf) = ch_Cfnfnf
+assert(1 == extracted1i_Cfnfnf)
+assert(2 == extracted2i_Cfnfnf)
+assert('a' == extracted1ch_Cfnfnf)
+assert('b' == extracted2ch_Cfnfnf)
+
+assert(1 == i_Cfnfnf.`a b`)
+assert(2 == i_Cfnfnf.a)
+assert('a' == ch_Cfnfnf.`a b`)
+assert('b' == ch_Cfnfnf.a)
+
+
+val ch_Rtpvtpvt = new Rtpvtpvt('a', 'b')
+val i_Rtpvtpvt = new Rtpvtpvt(1, 2)
+assert(1 == i_Rtpvtpvt.p1)
+assert(2 == i_Rtpvtpvt.p2)
+assert('a' == ch_Rtpvtpvt.p1)
+assert('b' == ch_Rtpvtpvt.p2)
+
+
+val ch_Rtpvtpvf = new Rtpvtpvf('a', 'b')
+val i_Rtpvtpvf = new Rtpvtpvf(1, 2)
+assert(1 == i_Rtpvtpvf.p1)
+assert('a' == ch_Rtpvtpvf.p1)
+
+
+val ch_Rtpvtvt = new Rtpvtvt('a', 'b')
+val i_Rtpvtvt = new Rtpvtvt(1, 2)
+assert(2 == i_Rtpvtvt.a)
+assert('b' == ch_Rtpvtvt.a)
+assert(1 == i_Rtpvtvt.p1)
+assert(2 == i_Rtpvtvt.p2)
+assert('a' == ch_Rtpvtvt.p1)
+assert('b' == ch_Rtpvtvt.p2)
+
+
+val ch_Rtpvtvf = new Rtpvtvf('a', 'b')
+val i_Rtpvtvf = new Rtpvtvf(1, 2)
+assert(2 == i_Rtpvtvf.a)
+assert('b' == ch_Rtpvtvf.a)
+assert(1 == i_Rtpvtvf.p1)
+assert('a' == ch_Rtpvtvf.p1)
+
+
+val ch_Rtpvtnt = new Rtpvtnt('a', 'b')
+val i_Rtpvtnt = new Rtpvtnt(1, 2)
+assert(1 == i_Rtpvtnt.p1)
+assert(2 == i_Rtpvtnt.p2)
+assert('a' == ch_Rtpvtnt.p1)
+assert('b' == ch_Rtpvtnt.p2)
+
+
+val ch_Rtpvtnf = new Rtpvtnf('a', 'b')
+val i_Rtpvtnf = new Rtpvtnf(1, 2)
+assert(1 == i_Rtpvtnf.p1)
+assert('a' == ch_Rtpvtnf.p1)
+
+
+val ch_Rtpvfpvt = new Rtpvfpvt('a', 'b')
+val i_Rtpvfpvt = new Rtpvfpvt(1, 2)
+assert(2 == i_Rtpvfpvt.p2)
+assert('b' == ch_Rtpvfpvt.p2)
+
+
+val ch_Rtpvfvt = new Rtpvfvt('a', 'b')
+val i_Rtpvfvt = new Rtpvfvt(1, 2)
+assert(2 == i_Rtpvfvt.a)
+assert('b' == ch_Rtpvfvt.a)
+assert(2 == i_Rtpvfvt.p2)
+assert('b' == ch_Rtpvfvt.p2)
+
+
+val ch_Rtpvfnt = new Rtpvfnt('a', 'b')
+val i_Rtpvfnt = new Rtpvfnt(1, 2)
+assert(2 == i_Rtpvfnt.p2)
+assert('b' == ch_Rtpvfnt.p2)
+
+
+val ch_Rtvtpvt = new Rtvtpvt('a', 'b')
+val i_Rtvtpvt = new Rtvtpvt(1, 2)
+assert(1 == i_Rtvtpvt.`a b`)
+assert('a' == ch_Rtvtpvt.`a b`)
+assert(1 == i_Rtvtpvt.p1)
+assert(2 == i_Rtvtpvt.p2)
+assert('a' == ch_Rtvtpvt.p1)
+assert('b' == ch_Rtvtpvt.p2)
+
+
+val ch_Rtvtpvf = new Rtvtpvf('a', 'b')
+val i_Rtvtpvf = new Rtvtpvf(1, 2)
+assert(1 == i_Rtvtpvf.`a b`)
+assert('a' == ch_Rtvtpvf.`a b`)
+assert(1 == i_Rtvtpvf.p1)
+assert('a' == ch_Rtvtpvf.p1)
+
+
+val ch_Rtvtvt = new Rtvtvt('a', 'b')
+val i_Rtvtvt = new Rtvtvt(1, 2)
+assert(1 == i_Rtvtvt.`a b`)
+assert(2 == i_Rtvtvt.a)
+assert('a' == ch_Rtvtvt.`a b`)
+assert('b' == ch_Rtvtvt.a)
+assert(1 == i_Rtvtvt.p1)
+assert(2 == i_Rtvtvt.p2)
+assert('a' == ch_Rtvtvt.p1)
+assert('b' == ch_Rtvtvt.p2)
+
+
+val ch_Rtvtvf = new Rtvtvf('a', 'b')
+val i_Rtvtvf = new Rtvtvf(1, 2)
+assert(1 == i_Rtvtvf.`a b`)
+assert(2 == i_Rtvtvf.a)
+assert('a' == ch_Rtvtvf.`a b`)
+assert('b' == ch_Rtvtvf.a)
+assert(1 == i_Rtvtvf.p1)
+assert('a' == ch_Rtvtvf.p1)
+
+
+val ch_Rtvtnt = new Rtvtnt('a', 'b')
+val i_Rtvtnt = new Rtvtnt(1, 2)
+assert(1 == i_Rtvtnt.`a b`)
+assert('a' == ch_Rtvtnt.`a b`)
+assert(1 == i_Rtvtnt.p1)
+assert(2 == i_Rtvtnt.p2)
+assert('a' == ch_Rtvtnt.p1)
+assert('b' == ch_Rtvtnt.p2)
+
+
+val ch_Rtvtnf = new Rtvtnf('a', 'b')
+val i_Rtvtnf = new Rtvtnf(1, 2)
+assert(1 == i_Rtvtnf.`a b`)
+assert('a' == ch_Rtvtnf.`a b`)
+assert(1 == i_Rtvtnf.p1)
+assert('a' == ch_Rtvtnf.p1)
+
+
+val ch_Rtvfpvt = new Rtvfpvt('a', 'b')
+val i_Rtvfpvt = new Rtvfpvt(1, 2)
+assert(1 == i_Rtvfpvt.`a b`)
+assert('a' == ch_Rtvfpvt.`a b`)
+assert(2 == i_Rtvfpvt.p2)
+assert('b' == ch_Rtvfpvt.p2)
+
+
+val ch_Rtvfvt = new Rtvfvt('a', 'b')
+val i_Rtvfvt = new Rtvfvt(1, 2)
+assert(1 == i_Rtvfvt.`a b`)
+assert(2 == i_Rtvfvt.a)
+assert('a' == ch_Rtvfvt.`a b`)
+assert('b' == ch_Rtvfvt.a)
+assert(2 == i_Rtvfvt.p2)
+assert('b' == ch_Rtvfvt.p2)
+
+
+val ch_Rtvfnt = new Rtvfnt('a', 'b')
+val i_Rtvfnt = new Rtvfnt(1, 2)
+assert(1 == i_Rtvfnt.`a b`)
+assert('a' == ch_Rtvfnt.`a b`)
+assert(2 == i_Rtvfnt.p2)
+assert('b' == ch_Rtvfnt.p2)
+
+
+val ch_Rtntpvt = new Rtntpvt('a', 'b')
+val i_Rtntpvt = new Rtntpvt(1, 2)
+assert(1 == i_Rtntpvt.p1)
+assert(2 == i_Rtntpvt.p2)
+assert('a' == ch_Rtntpvt.p1)
+assert('b' == ch_Rtntpvt.p2)
+
+
+val ch_Rtntpvf = new Rtntpvf('a', 'b')
+val i_Rtntpvf = new Rtntpvf(1, 2)
+assert(1 == i_Rtntpvf.p1)
+assert('a' == ch_Rtntpvf.p1)
+
+
+val ch_Rtntvt = new Rtntvt('a', 'b')
+val i_Rtntvt = new Rtntvt(1, 2)
+assert(2 == i_Rtntvt.a)
+assert('b' == ch_Rtntvt.a)
+assert(1 == i_Rtntvt.p1)
+assert(2 == i_Rtntvt.p2)
+assert('a' == ch_Rtntvt.p1)
+assert('b' == ch_Rtntvt.p2)
+
+
+val ch_Rtntvf = new Rtntvf('a', 'b')
+val i_Rtntvf = new Rtntvf(1, 2)
+assert(2 == i_Rtntvf.a)
+assert('b' == ch_Rtntvf.a)
+assert(1 == i_Rtntvf.p1)
+assert('a' == ch_Rtntvf.p1)
+
+
+val ch_Rtntnt = new Rtntnt('a', 'b')
+val i_Rtntnt = new Rtntnt(1, 2)
+assert(1 == i_Rtntnt.p1)
+assert(2 == i_Rtntnt.p2)
+assert('a' == ch_Rtntnt.p1)
+assert('b' == ch_Rtntnt.p2)
+
+
+val ch_Rtntnf = new Rtntnf('a', 'b')
+val i_Rtntnf = new Rtntnf(1, 2)
+assert(1 == i_Rtntnf.p1)
+assert('a' == ch_Rtntnf.p1)
+
+
+val ch_Rtnfpvt = new Rtnfpvt('a', 'b')
+val i_Rtnfpvt = new Rtnfpvt(1, 2)
+assert(2 == i_Rtnfpvt.p2)
+assert('b' == ch_Rtnfpvt.p2)
+
+
+val ch_Rtnfvt = new Rtnfvt('a', 'b')
+val i_Rtnfvt = new Rtnfvt(1, 2)
+assert(2 == i_Rtnfvt.a)
+assert('b' == ch_Rtnfvt.a)
+assert(2 == i_Rtnfvt.p2)
+assert('b' == ch_Rtnfvt.p2)
+
+
+val ch_Rtnfnt = new Rtnfnt('a', 'b')
+val i_Rtnfnt = new Rtnfnt(1, 2)
+assert(2 == i_Rtnfnt.p2)
+assert('b' == ch_Rtnfnt.p2)
+
+
+val ch_Rfpvtpvt = new Rfpvtpvt('a', 'b')
+val i_Rfpvtpvt = new Rfpvtpvt(1, 2)
+assert(1 == i_Rfpvtpvt.p1)
+assert(2 == i_Rfpvtpvt.p2)
+assert('a' == ch_Rfpvtpvt.p1)
+assert('b' == ch_Rfpvtpvt.p2)
+
+
+val ch_Rfpvtpvf = new Rfpvtpvf('a', 'b')
+val i_Rfpvtpvf = new Rfpvtpvf(1, 2)
+assert(1 == i_Rfpvtpvf.p1)
+assert('a' == ch_Rfpvtpvf.p1)
+
+
+val ch_Rfpvtvt = new Rfpvtvt('a', 'b')
+val i_Rfpvtvt = new Rfpvtvt(1, 2)
+assert(2 == i_Rfpvtvt.a)
+assert('b' == ch_Rfpvtvt.a)
+assert(1 == i_Rfpvtvt.p1)
+assert(2 == i_Rfpvtvt.p2)
+assert('a' == ch_Rfpvtvt.p1)
+assert('b' == ch_Rfpvtvt.p2)
+
+
+val ch_Rfpvtvf = new Rfpvtvf('a', 'b')
+val i_Rfpvtvf = new Rfpvtvf(1, 2)
+assert(2 == i_Rfpvtvf.a)
+assert('b' == ch_Rfpvtvf.a)
+assert(1 == i_Rfpvtvf.p1)
+assert('a' == ch_Rfpvtvf.p1)
+
+
+val ch_Rfpvtnt = new Rfpvtnt('a', 'b')
+val i_Rfpvtnt = new Rfpvtnt(1, 2)
+assert(1 == i_Rfpvtnt.p1)
+assert(2 == i_Rfpvtnt.p2)
+assert('a' == ch_Rfpvtnt.p1)
+assert('b' == ch_Rfpvtnt.p2)
+
+
+val ch_Rfpvtnf = new Rfpvtnf('a', 'b')
+val i_Rfpvtnf = new Rfpvtnf(1, 2)
+assert(1 == i_Rfpvtnf.p1)
+assert('a' == ch_Rfpvtnf.p1)
+
+
+val ch_Rfpvfpvt = new Rfpvfpvt('a', 'b')
+val i_Rfpvfpvt = new Rfpvfpvt(1, 2)
+assert(2 == i_Rfpvfpvt.p2)
+assert('b' == ch_Rfpvfpvt.p2)
+
+
+val ch_Rfpvfpvf = new Rfpvfpvf('a', 'b')
+val i_Rfpvfpvf = new Rfpvfpvf(1, 2)
+
+
+val ch_Rfpvfvt = new Rfpvfvt('a', 'b')
+val i_Rfpvfvt = new Rfpvfvt(1, 2)
+assert(2 == i_Rfpvfvt.a)
+assert('b' == ch_Rfpvfvt.a)
+assert(2 == i_Rfpvfvt.p2)
+assert('b' == ch_Rfpvfvt.p2)
+
+
+val ch_Rfpvfvf = new Rfpvfvf('a', 'b')
+val i_Rfpvfvf = new Rfpvfvf(1, 2)
+assert(2 == i_Rfpvfvf.a)
+assert('b' == ch_Rfpvfvf.a)
+
+
+val ch_Rfpvfnt = new Rfpvfnt('a', 'b')
+val i_Rfpvfnt = new Rfpvfnt(1, 2)
+assert(2 == i_Rfpvfnt.p2)
+assert('b' == ch_Rfpvfnt.p2)
+
+
+val ch_Rfpvfnf = new Rfpvfnf('a', 'b')
+val i_Rfpvfnf = new Rfpvfnf(1, 2)
+
+
+val ch_Rfvtpvt = new Rfvtpvt('a', 'b')
+val i_Rfvtpvt = new Rfvtpvt(1, 2)
+assert(1 == i_Rfvtpvt.`a b`)
+assert('a' == ch_Rfvtpvt.`a b`)
+assert(1 == i_Rfvtpvt.p1)
+assert(2 == i_Rfvtpvt.p2)
+assert('a' == ch_Rfvtpvt.p1)
+assert('b' == ch_Rfvtpvt.p2)
+
+
+val ch_Rfvtpvf = new Rfvtpvf('a', 'b')
+val i_Rfvtpvf = new Rfvtpvf(1, 2)
+assert(1 == i_Rfvtpvf.`a b`)
+assert('a' == ch_Rfvtpvf.`a b`)
+assert(1 == i_Rfvtpvf.p1)
+assert('a' == ch_Rfvtpvf.p1)
+
+
+val ch_Rfvtvt = new Rfvtvt('a', 'b')
+val i_Rfvtvt = new Rfvtvt(1, 2)
+assert(1 == i_Rfvtvt.`a b`)
+assert(2 == i_Rfvtvt.a)
+assert('a' == ch_Rfvtvt.`a b`)
+assert('b' == ch_Rfvtvt.a)
+assert(1 == i_Rfvtvt.p1)
+assert(2 == i_Rfvtvt.p2)
+assert('a' == ch_Rfvtvt.p1)
+assert('b' == ch_Rfvtvt.p2)
+
+
+val ch_Rfvtvf = new Rfvtvf('a', 'b')
+val i_Rfvtvf = new Rfvtvf(1, 2)
+assert(1 == i_Rfvtvf.`a b`)
+assert(2 == i_Rfvtvf.a)
+assert('a' == ch_Rfvtvf.`a b`)
+assert('b' == ch_Rfvtvf.a)
+assert(1 == i_Rfvtvf.p1)
+assert('a' == ch_Rfvtvf.p1)
+
+
+val ch_Rfvtnt = new Rfvtnt('a', 'b')
+val i_Rfvtnt = new Rfvtnt(1, 2)
+assert(1 == i_Rfvtnt.`a b`)
+assert('a' == ch_Rfvtnt.`a b`)
+assert(1 == i_Rfvtnt.p1)
+assert(2 == i_Rfvtnt.p2)
+assert('a' == ch_Rfvtnt.p1)
+assert('b' == ch_Rfvtnt.p2)
+
+
+val ch_Rfvtnf = new Rfvtnf('a', 'b')
+val i_Rfvtnf = new Rfvtnf(1, 2)
+assert(1 == i_Rfvtnf.`a b`)
+assert('a' == ch_Rfvtnf.`a b`)
+assert(1 == i_Rfvtnf.p1)
+assert('a' == ch_Rfvtnf.p1)
+
+
+val ch_Rfvfpvt = new Rfvfpvt('a', 'b')
+val i_Rfvfpvt = new Rfvfpvt(1, 2)
+assert(1 == i_Rfvfpvt.`a b`)
+assert('a' == ch_Rfvfpvt.`a b`)
+assert(2 == i_Rfvfpvt.p2)
+assert('b' == ch_Rfvfpvt.p2)
+
+
+val ch_Rfvfpvf = new Rfvfpvf('a', 'b')
+val i_Rfvfpvf = new Rfvfpvf(1, 2)
+assert(1 == i_Rfvfpvf.`a b`)
+assert('a' == ch_Rfvfpvf.`a b`)
+
+
+val ch_Rfvfvt = new Rfvfvt('a', 'b')
+val i_Rfvfvt = new Rfvfvt(1, 2)
+assert(1 == i_Rfvfvt.`a b`)
+assert(2 == i_Rfvfvt.a)
+assert('a' == ch_Rfvfvt.`a b`)
+assert('b' == ch_Rfvfvt.a)
+assert(2 == i_Rfvfvt.p2)
+assert('b' == ch_Rfvfvt.p2)
+
+
+val ch_Rfvfvf = new Rfvfvf('a', 'b')
+val i_Rfvfvf = new Rfvfvf(1, 2)
+assert(1 == i_Rfvfvf.`a b`)
+assert(2 == i_Rfvfvf.a)
+assert('a' == ch_Rfvfvf.`a b`)
+assert('b' == ch_Rfvfvf.a)
+
+
+val ch_Rfvfnt = new Rfvfnt('a', 'b')
+val i_Rfvfnt = new Rfvfnt(1, 2)
+assert(1 == i_Rfvfnt.`a b`)
+assert('a' == ch_Rfvfnt.`a b`)
+assert(2 == i_Rfvfnt.p2)
+assert('b' == ch_Rfvfnt.p2)
+
+
+val ch_Rfvfnf = new Rfvfnf('a', 'b')
+val i_Rfvfnf = new Rfvfnf(1, 2)
+assert(1 == i_Rfvfnf.`a b`)
+assert('a' == ch_Rfvfnf.`a b`)
+
+
+val ch_Rfntpvt = new Rfntpvt('a', 'b')
+val i_Rfntpvt = new Rfntpvt(1, 2)
+assert(1 == i_Rfntpvt.p1)
+assert(2 == i_Rfntpvt.p2)
+assert('a' == ch_Rfntpvt.p1)
+assert('b' == ch_Rfntpvt.p2)
+
+
+val ch_Rfntpvf = new Rfntpvf('a', 'b')
+val i_Rfntpvf = new Rfntpvf(1, 2)
+assert(1 == i_Rfntpvf.p1)
+assert('a' == ch_Rfntpvf.p1)
+
+
+val ch_Rfntvt = new Rfntvt('a', 'b')
+val i_Rfntvt = new Rfntvt(1, 2)
+assert(2 == i_Rfntvt.a)
+assert('b' == ch_Rfntvt.a)
+assert(1 == i_Rfntvt.p1)
+assert(2 == i_Rfntvt.p2)
+assert('a' == ch_Rfntvt.p1)
+assert('b' == ch_Rfntvt.p2)
+
+
+val ch_Rfntvf = new Rfntvf('a', 'b')
+val i_Rfntvf = new Rfntvf(1, 2)
+assert(2 == i_Rfntvf.a)
+assert('b' == ch_Rfntvf.a)
+assert(1 == i_Rfntvf.p1)
+assert('a' == ch_Rfntvf.p1)
+
+
+val ch_Rfntnt = new Rfntnt('a', 'b')
+val i_Rfntnt = new Rfntnt(1, 2)
+assert(1 == i_Rfntnt.p1)
+assert(2 == i_Rfntnt.p2)
+assert('a' == ch_Rfntnt.p1)
+assert('b' == ch_Rfntnt.p2)
+
+
+val ch_Rfntnf = new Rfntnf('a', 'b')
+val i_Rfntnf = new Rfntnf(1, 2)
+assert(1 == i_Rfntnf.p1)
+assert('a' == ch_Rfntnf.p1)
+
+
+val ch_Rfnfpvt = new Rfnfpvt('a', 'b')
+val i_Rfnfpvt = new Rfnfpvt(1, 2)
+assert(2 == i_Rfnfpvt.p2)
+assert('b' == ch_Rfnfpvt.p2)
+
+
+val ch_Rfnfpvf = new Rfnfpvf('a', 'b')
+val i_Rfnfpvf = new Rfnfpvf(1, 2)
+
+
+val ch_Rfnfvt = new Rfnfvt('a', 'b')
+val i_Rfnfvt = new Rfnfvt(1, 2)
+assert(2 == i_Rfnfvt.a)
+assert('b' == ch_Rfnfvt.a)
+assert(2 == i_Rfnfvt.p2)
+assert('b' == ch_Rfnfvt.p2)
+
+
+val ch_Rfnfvf = new Rfnfvf('a', 'b')
+val i_Rfnfvf = new Rfnfvf(1, 2)
+assert(2 == i_Rfnfvf.a)
+assert('b' == ch_Rfnfvf.a)
+
+
+val ch_Rfnfnt = new Rfnfnt('a', 'b')
+val i_Rfnfnt = new Rfnfnt(1, 2)
+assert(2 == i_Rfnfnt.p2)
+assert('b' == ch_Rfnfnt.p2)
+
+
+val ch_Rfnfnf = new Rfnfnf('a', 'b')
+val i_Rfnfnf = new Rfnfnf(1, 2)
+
+TestJoint.joint()
+}
diff --git a/test/files/run/t8831_many/generator.scala b/test/files/run/t8831_many/generator.scala
new file mode 100644
index 000000000000..28defb5620d1
--- /dev/null
+++ b/test/files/run/t8831_many/generator.scala
@@ -0,0 +1,93 @@
+//Generate the classes and assertions under test.
+case class TestCase(classType: String, specialized: Boolean, p1: ParamConfig, p2: ParamConfig) {
+  val className = s"${classType.headOption.getOrElse('r')}${specialized.toString().head}${abbr(p1)}${abbr(p2)}".capitalize
+  val tparams = if (specialized) "[@specialized(Int) A, @specialized(Int) B]" else "[A, B]"
+  def abbr(p: ParamConfig): String = p.modifier.split(' ').toSeq.map(_.headOption.getOrElse('n')).mkString + p.accessed.toString().head
+  //def access(param: ParamConfig, name: String) = if(param.accessed)
+  def decl(param: ParamConfig): String = param.aliasName.map(n => s"val $n = ${param.constructorName}\n").getOrElse("")
+  def renderClass: String = s"""$classType class $className$tparams(${p1.modifier} ${p1.constructorName}: A, ${p2.modifier} a: B){
+    ${decl(p1)}${decl(p2)}
+  }"""
+  
+  def accessConstr(p: ParamConfig) = Option(p).filterNot(p => p.modifier == "private val").filterNot(p => p.modifier == "" && classType == "").map(_.constructorName)
+  def testConstrCh(p: ParamConfig, expected: String) = accessConstr(p).map(name => s"assert($expected == ch_$className.$name)")
+  def testConstrI(p: ParamConfig, expected: String) = accessConstr(p).map(name => s"assert($expected == i_$className.$name)")
+  def testAliasCh(p: ParamConfig, expected: String) = p.aliasName.map(name => s"assert($expected == ch_$className.$name)")
+  def testAliasI(p: ParamConfig, expected: String) = p.aliasName.map(name => s"assert($expected == i_$className.$name)")
+  def testExtractors = Some(s"""val $className(extracted1i_$className, extracted2i_$className) = i_$className
+  |val $className(extracted1ch_$className, extracted2ch_$className) = ch_$className
+  |assert(1 == extracted1i_$className)
+  |assert(2 == extracted2i_$className)
+  |assert('a' == extracted1ch_$className)
+  |assert('b' == extracted2ch_$className)
+  |""".stripMargin).filter(_ => classType == "case")
+  val assertions = List(
+    testExtractors,
+    testConstrI(p1, "1"),
+    testConstrI(p2, "2"),
+    testConstrCh(p1, "'a'"),
+    testConstrCh(p2, "'b'"),
+    testAliasI(p1, "1"),
+    testAliasI(p2, "2"),
+    testAliasCh(p1, "'a'"),
+    testAliasCh(p2, "'b'"),
+  ).collect{ case Some(t) => t }
+  def renderTests: String = (instantiateChar :: instantiateInt :: assertions).mkString("\n", "\n", "\n")
+  def instantiateChar = s"val ch_$className = new $className('a', 'b')"
+  def instantiateInt = s"val i_$className = new $className(1, 2)"
+  
+}
+
+case class ParamConfig(modifier: String, constructorName: String, aliasName: Option[String]) {
+  def accessed = aliasName.isDefined
+}
+
+object Generator {
+  def paramConfigurations(constructorName: String, aliasName: String) = for {
+    modifier <- List("private val", "val", "")
+    accessed <- List(true, false)
+  } yield ParamConfig(modifier, constructorName, Option(aliasName).filter(_ => accessed))
+
+  def hasVal(p1: ParamConfig, p2: ParamConfig) = p1.modifier.contains("val") || p2.modifier.contains("val")
+
+  val configurations = for {
+    classConfig <- List("case", "")
+    specialized <- List(true, false)
+    p1config <- paramConfigurations("`a b`", "p1")
+    p2config <- paramConfigurations("a", "p2")
+    if (!(specialized && !(p1config.accessed || p2config.accessed)))
+  } yield TestCase(classConfig, specialized, p1config, p2config)
+
+  def main(args: Array[String]): Unit = {
+    import java.io.File
+    import java.io.PrintWriter
+
+    val classes = new File("Classes_1.scala")
+    val tests = new File("Tests_2.scala")
+    val classWriter = new PrintWriter(classes)
+    val testWriter = new PrintWriter(tests)
+    
+    for(testClass <- configurations) {
+      classWriter.write(testClass.renderClass)
+      classWriter.write("\n")
+    }
+
+    //test both separate and joint compilation. 
+
+    testWriter.write("object Test extends App {\n")
+    classWriter.write("object TestJoint  {\n def joint(): Unit = {\n")
+    for(testClass <- configurations){
+      classWriter.write(testClass.renderTests)
+      classWriter.write("\n")
+      testWriter.write(testClass.renderTests)
+      testWriter.write("\n")
+    }
+    classWriter.write("\n}}\n")
+    testWriter.write("TestJoint.joint()")
+
+    testWriter.write("\n}\n")
+    classWriter.close()
+    testWriter.close()
+    
+  }
+}
\ No newline at end of file

From e001e0b17abd26318b5ee8c501bc2fccee370fac Mon Sep 17 00:00:00 2001
From: Martijn Hoekstra <martijn.hoekstra@cargoxs.com>
Date: Wed, 3 Jun 2020 22:43:17 +0200
Subject: [PATCH 3/4] work around incorrectly unexpanded names

---
 .../tools/nsc/transform/Constructors.scala    |   22 +-
 .../scala/reflect/internal/StdNames.scala     |    3 +
 test/files/run/t10625.check                   |    3 +
 test/files/run/t10625.scala                   |    8 +
 test/files/run/t8831_many/Classes_1.scala     | 2577 ++++++-----------
 test/files/run/t8831_many/Tests_2.scala       | 2199 +++++---------
 test/files/run/t8831_many/generator.scala     |   12 +-
 7 files changed, 1647 insertions(+), 3177 deletions(-)
 create mode 100644 test/files/run/t10625.check
 create mode 100644 test/files/run/t10625.scala

diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index 5cb6955a0bc5..8b80df2b247c 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -474,15 +474,21 @@ abstract class Constructors extends Statics with Transform with TypingTransforme
     def usesSpecializedField = intoConstructor.usesSpecializedField
 
     // The constructor parameter corresponding to an accessor
-    def parameter(acc: Symbol): Symbol = parameterNamed(acc.unexpandedName.getterName)
+    def parameter(acc: Symbol): Symbol = {
+      import scala.util.Try
+      //works around the edge case where unexpandedName over-unexpands shenanigans like literal $$ or `$#`
+      def unexpanded = parameterNamed(acc.unexpandedName.getterName)
+      def expanded = parameterNamed(acc.getterName)
+      unexpanded.orElse(expanded).swap.map(abort).merge
+    }
 
-    // The constructor parameter with given name. This means the parameter
-    // has given name, or starts with given name, and continues with a `$` afterwards.
-    def parameterNamed(name: Name): Symbol =
+    // The constructor parameter with given getter name. This means the parameter name
+    // decodes to the same name that the getter decodes to
+    def parameterNamed(name: Name): Either[String, Symbol] =  
       primaryConstrParams.filter(_.name.decodedName == name.decodedName) match {
-        case List(p) => p
-        case Nil     => abort(s"$name not in $primaryConstrParams")
-        case ps      => abort(s"$name matches multiple constructor paramters $ps")
+        case List(p) => Right(p)
+        case Nil     => Left(s"No constructor parameter named $name (decoded to ${name.decodedName}) found in list of constructor parameters $primaryConstrParams (decoded to ${primaryConstrParams.map(_.decodedName)})")
+        case ps      => Left(s"$name matches multiple constructor parameters $ps")
       }
 
     // A transformer for expressions that go into the constructor
@@ -529,7 +535,7 @@ abstract class Constructors extends Statics with Transform with TypingTransforme
           else if (canBeSupplanted(tree.symbol))
             gen.mkAttributedIdent(parameter(tree.symbol)) setPos tree.pos
           else if (tree.symbol.outerSource == clazz && !isDelayedInitSubclass)
-            gen.mkAttributedIdent(parameterNamed(nme.OUTER)) setPos tree.pos
+            gen.mkAttributedIdent(parameterNamed(nme.OUTER).fold(abort, identity)).setPos(tree.pos)
           else
             super.transform(tree)
 
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index f29e8046379b..213a2738bf1a 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -437,6 +437,9 @@ trait StdNames {
      *  Look backward from the end of the string for "$$", and take the
      *  part of the string after that; but if the string is "$$$" or longer,
      *  be sure to retain the extra dollars.
+     *  If the name happens to be a back quoted name containing literal $$
+     *  or $ followed by an operator that gets encoded, go directly to compiler
+     *  crash. Do not pass go and don't even think about collecting any $$
      */
     def unexpandedName(name: Name): Name = name lastIndexOf "$$" match {
       case 0 | -1 => name
diff --git a/test/files/run/t10625.check b/test/files/run/t10625.check
new file mode 100644
index 000000000000..a65cf05470e7
--- /dev/null
+++ b/test/files/run/t10625.check
@@ -0,0 +1,3 @@
+1
+1
+Some(1)
diff --git a/test/files/run/t10625.scala b/test/files/run/t10625.scala
new file mode 100644
index 000000000000..9f7cf82ab178
--- /dev/null
+++ b/test/files/run/t10625.scala
@@ -0,0 +1,8 @@
+case class WhyNot(`^$#`: Int)
+object Test extends App {
+  val wn = WhyNot(1)
+  println(wn.`^$#`)
+  val WhyNot(i) = wn
+  println(i)
+  println(WhyNot.unapply(wn))
+}
diff --git a/test/files/run/t8831_many/Classes_1.scala b/test/files/run/t8831_many/Classes_1.scala
index 1f10723e8898..e75474b447bc 100644
--- a/test/files/run/t8831_many/Classes_1.scala
+++ b/test/files/run/t8831_many/Classes_1.scala
@@ -1,2011 +1,1120 @@
-case class Ctpvtpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+case class Cpvt_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Ctpvtpvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+case class Cpvt_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
     val p1 = `a b`
 
   }
-case class Ctpvtvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+case class Cpvt_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Ctpvtvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+case class Cpvt_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
     val p1 = `a b`
 
   }
-case class Ctpvtnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+case class Cpvt_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Ctpvtnf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+case class Cpvt_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
     val p1 = `a b`
 
   }
-case class Ctpvfpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+case class Cpvf_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
     val p2 = a
 
   }
-case class Ctpvfvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    val p2 = a
-
-  }
-case class Ctpvfnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    val p2 = a
-
-  }
-case class Ctvtpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Ctvtpvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
-case class Ctvtvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Ctvtvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
-case class Ctvtnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Ctvtnf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
-case class Ctvfpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
-case class Ctvfvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p2 = a
-
-  }
-case class Ctvfnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p2 = a
-
-  }
-case class Ctntpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Ctntpvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
-case class Ctntvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Ctntvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
-case class Ctntnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Ctntnf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
-case class Ctnfpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p2 = a
-
-  }
-case class Ctnfvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p2 = a
-
-  }
-case class Ctnfnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p2 = a
-
-  }
-case class Cfpvtpvt[A, B](private val `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cfpvtpvf[A, B](private val `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
-case class Cfpvtvt[A, B](private val `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cfpvtvf[A, B](private val `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
-case class Cfpvtnt[A, B](private val `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cfpvtnf[A, B](private val `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
-case class Cfpvfpvt[A, B](private val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
-case class Cfpvfpvf[A, B](private val `a b`: A, private val a: B){
+case class Cpvf_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
     
   }
-case class Cfpvfvt[A, B](private val `a b`: A, val a: B){
+case class Cpvf_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
     val p2 = a
 
   }
-case class Cfpvfvf[A, B](private val `a b`: A, val a: B){
+case class Cpvf_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
     
   }
-case class Cfpvfnt[A, B](private val `a b`: A,  a: B){
+case class Cpvf_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
     val p2 = a
 
   }
-case class Cfpvfnf[A, B](private val `a b`: A,  a: B){
+case class Cpvf_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
     
   }
-case class Cfvtpvt[A, B](val `a b`: A, private val a: B){
+case class Cvt_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Cfvtpvf[A, B](val `a b`: A, private val a: B){
+case class Cvt_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
     val p1 = `a b`
 
   }
-case class Cfvtvt[A, B](val `a b`: A, val a: B){
+case class Cvt_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Cfvtvf[A, B](val `a b`: A, val a: B){
+case class Cvt_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
     val p1 = `a b`
 
   }
-case class Cfvtnt[A, B](val `a b`: A,  a: B){
+case class Cvt_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Cfvtnf[A, B](val `a b`: A,  a: B){
+case class Cvt_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
     val p1 = `a b`
 
   }
-case class Cfvfpvt[A, B](val `a b`: A, private val a: B){
+case class Cvf_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
     val p2 = a
 
   }
-case class Cfvfpvf[A, B](val `a b`: A, private val a: B){
+case class Cvf_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
     
   }
-case class Cfvfvt[A, B](val `a b`: A, val a: B){
+case class Cvf_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
     val p2 = a
 
   }
-case class Cfvfvf[A, B](val `a b`: A, val a: B){
+case class Cvf_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
     
   }
-case class Cfvfnt[A, B](val `a b`: A,  a: B){
+case class Cvf_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
     val p2 = a
 
   }
-case class Cfvfnf[A, B](val `a b`: A,  a: B){
+case class Cvf_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
     
   }
-case class Cfntpvt[A, B]( `a b`: A, private val a: B){
+case class Cnt_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Cfntpvf[A, B]( `a b`: A, private val a: B){
+case class Cnt_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
     val p1 = `a b`
 
   }
-case class Cfntvt[A, B]( `a b`: A, val a: B){
+case class Cnt_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Cfntvf[A, B]( `a b`: A, val a: B){
+case class Cnt_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
     val p1 = `a b`
 
   }
-case class Cfntnt[A, B]( `a b`: A,  a: B){
+case class Cnt_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
     val p1 = `a b`
 val p2 = a
 
   }
-case class Cfntnf[A, B]( `a b`: A,  a: B){
+case class Cnt_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
     val p1 = `a b`
 
   }
-case class Cfnfpvt[A, B]( `a b`: A, private val a: B){
+case class Cnf_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
     val p2 = a
 
   }
-case class Cfnfpvf[A, B]( `a b`: A, private val a: B){
+case class Cnf_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
     
   }
-case class Cfnfvt[A, B]( `a b`: A, val a: B){
+case class Cnf_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
     val p2 = a
 
   }
-case class Cfnfvf[A, B]( `a b`: A, val a: B){
+case class Cnf_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
     
   }
-case class Cfnfnt[A, B]( `a b`: A,  a: B){
+case class Cnf_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
     val p2 = a
 
   }
-case class Cfnfnf[A, B]( `a b`: A,  a: B){
+case class Cnf_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
     
   }
- class Rtpvtpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+ class Rpvt_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rtpvtpvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+ class Rpvt_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
     val p1 = `a b`
 
   }
- class Rtpvtvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+ class Rpvt_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rtpvtvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+ class Rpvt_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
     val p1 = `a b`
 
   }
- class Rtpvtnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+ class Rpvt_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rtpvtnf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+ class Rpvt_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
     val p1 = `a b`
 
   }
- class Rtpvfpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
- class Rtpvfvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    val p2 = a
-
-  }
- class Rtpvfnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+ class Rpvf_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
     val p2 = a
 
   }
- class Rtvtpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rtvtpvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
- class Rtvtvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rtvtvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
- class Rtvtnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rtvtnf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
- class Rtvfpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
- class Rtvfvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p2 = a
-
-  }
- class Rtvfnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p2 = a
-
-  }
- class Rtntpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rtntpvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
- class Rtntvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rtntvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
- class Rtntnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rtntnf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
- class Rtnfpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p2 = a
-
-  }
- class Rtnfvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p2 = a
-
-  }
- class Rtnfnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p2 = a
-
-  }
- class Rfpvtpvt[A, B](private val `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rfpvtpvf[A, B](private val `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
- class Rfpvtvt[A, B](private val `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rfpvtvf[A, B](private val `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
- class Rfpvtnt[A, B](private val `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rfpvtnf[A, B](private val `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
- class Rfpvfpvt[A, B](private val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
- class Rfpvfpvf[A, B](private val `a b`: A, private val a: B){
+ class Rpvf_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
     
   }
- class Rfpvfvt[A, B](private val `a b`: A, val a: B){
+ class Rpvf_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
     val p2 = a
 
   }
- class Rfpvfvf[A, B](private val `a b`: A, val a: B){
+ class Rpvf_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
     
   }
- class Rfpvfnt[A, B](private val `a b`: A,  a: B){
+ class Rpvf_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
     val p2 = a
 
   }
- class Rfpvfnf[A, B](private val `a b`: A,  a: B){
+ class Rpvf_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
     
   }
- class Rfvtpvt[A, B](val `a b`: A, private val a: B){
+ class Rvt_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rfvtpvf[A, B](val `a b`: A, private val a: B){
+ class Rvt_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
     val p1 = `a b`
 
   }
- class Rfvtvt[A, B](val `a b`: A, val a: B){
+ class Rvt_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rfvtvf[A, B](val `a b`: A, val a: B){
+ class Rvt_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
     val p1 = `a b`
 
   }
- class Rfvtnt[A, B](val `a b`: A,  a: B){
+ class Rvt_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rfvtnf[A, B](val `a b`: A,  a: B){
+ class Rvt_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
     val p1 = `a b`
 
   }
- class Rfvfpvt[A, B](val `a b`: A, private val a: B){
+ class Rvf_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
     val p2 = a
 
   }
- class Rfvfpvf[A, B](val `a b`: A, private val a: B){
+ class Rvf_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
     
   }
- class Rfvfvt[A, B](val `a b`: A, val a: B){
+ class Rvf_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
     val p2 = a
 
   }
- class Rfvfvf[A, B](val `a b`: A, val a: B){
+ class Rvf_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
     
   }
- class Rfvfnt[A, B](val `a b`: A,  a: B){
+ class Rvf_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
     val p2 = a
 
   }
- class Rfvfnf[A, B](val `a b`: A,  a: B){
+ class Rvf_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
     
   }
- class Rfntpvt[A, B]( `a b`: A, private val a: B){
+ class Rnt_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rfntpvf[A, B]( `a b`: A, private val a: B){
+ class Rnt_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
     val p1 = `a b`
 
   }
- class Rfntvt[A, B]( `a b`: A, val a: B){
+ class Rnt_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rfntvf[A, B]( `a b`: A, val a: B){
+ class Rnt_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
     val p1 = `a b`
 
   }
- class Rfntnt[A, B]( `a b`: A,  a: B){
+ class Rnt_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
     val p1 = `a b`
 val p2 = a
 
   }
- class Rfntnf[A, B]( `a b`: A,  a: B){
+ class Rnt_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
     val p1 = `a b`
 
   }
- class Rfnfpvt[A, B]( `a b`: A, private val a: B){
+ class Rnf_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
     val p2 = a
 
   }
- class Rfnfpvf[A, B]( `a b`: A, private val a: B){
+ class Rnf_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
     
   }
- class Rfnfvt[A, B]( `a b`: A, val a: B){
+ class Rnf_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
     val p2 = a
 
   }
- class Rfnfvf[A, B]( `a b`: A, val a: B){
+ class Rnf_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
     
   }
- class Rfnfnt[A, B]( `a b`: A,  a: B){
+ class Rnf_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
     val p2 = a
 
   }
- class Rfnfnf[A, B]( `a b`: A,  a: B){
+ class Rnf_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
     
   }
 object TestJoint  {
  def joint(): Unit = {
 
-val ch_Ctpvtpvt = new Ctpvtpvt('a', 'b')
-val i_Ctpvtpvt = new Ctpvtpvt(1, 2)
-val Ctpvtpvt(extracted1i_Ctpvtpvt, extracted2i_Ctpvtpvt) = i_Ctpvtpvt
-val Ctpvtpvt(extracted1ch_Ctpvtpvt, extracted2ch_Ctpvtpvt) = ch_Ctpvtpvt
-assert(1 == extracted1i_Ctpvtpvt)
-assert(2 == extracted2i_Ctpvtpvt)
-assert('a' == extracted1ch_Ctpvtpvt)
-assert('b' == extracted2ch_Ctpvtpvt)
-
-assert(1 == i_Ctpvtpvt.p1)
-assert(2 == i_Ctpvtpvt.p2)
-assert('a' == ch_Ctpvtpvt.p1)
-assert('b' == ch_Ctpvtpvt.p2)
-
-
-val ch_Ctpvtpvf = new Ctpvtpvf('a', 'b')
-val i_Ctpvtpvf = new Ctpvtpvf(1, 2)
-val Ctpvtpvf(extracted1i_Ctpvtpvf, extracted2i_Ctpvtpvf) = i_Ctpvtpvf
-val Ctpvtpvf(extracted1ch_Ctpvtpvf, extracted2ch_Ctpvtpvf) = ch_Ctpvtpvf
-assert(1 == extracted1i_Ctpvtpvf)
-assert(2 == extracted2i_Ctpvtpvf)
-assert('a' == extracted1ch_Ctpvtpvf)
-assert('b' == extracted2ch_Ctpvtpvf)
-
-assert(1 == i_Ctpvtpvf.p1)
-assert('a' == ch_Ctpvtpvf.p1)
-
-
-val ch_Ctpvtvt = new Ctpvtvt('a', 'b')
-val i_Ctpvtvt = new Ctpvtvt(1, 2)
-val Ctpvtvt(extracted1i_Ctpvtvt, extracted2i_Ctpvtvt) = i_Ctpvtvt
-val Ctpvtvt(extracted1ch_Ctpvtvt, extracted2ch_Ctpvtvt) = ch_Ctpvtvt
-assert(1 == extracted1i_Ctpvtvt)
-assert(2 == extracted2i_Ctpvtvt)
-assert('a' == extracted1ch_Ctpvtvt)
-assert('b' == extracted2ch_Ctpvtvt)
-
-assert(2 == i_Ctpvtvt.a)
-assert('b' == ch_Ctpvtvt.a)
-assert(1 == i_Ctpvtvt.p1)
-assert(2 == i_Ctpvtvt.p2)
-assert('a' == ch_Ctpvtvt.p1)
-assert('b' == ch_Ctpvtvt.p2)
-
-
-val ch_Ctpvtvf = new Ctpvtvf('a', 'b')
-val i_Ctpvtvf = new Ctpvtvf(1, 2)
-val Ctpvtvf(extracted1i_Ctpvtvf, extracted2i_Ctpvtvf) = i_Ctpvtvf
-val Ctpvtvf(extracted1ch_Ctpvtvf, extracted2ch_Ctpvtvf) = ch_Ctpvtvf
-assert(1 == extracted1i_Ctpvtvf)
-assert(2 == extracted2i_Ctpvtvf)
-assert('a' == extracted1ch_Ctpvtvf)
-assert('b' == extracted2ch_Ctpvtvf)
-
-assert(2 == i_Ctpvtvf.a)
-assert('b' == ch_Ctpvtvf.a)
-assert(1 == i_Ctpvtvf.p1)
-assert('a' == ch_Ctpvtvf.p1)
-
-
-val ch_Ctpvtnt = new Ctpvtnt('a', 'b')
-val i_Ctpvtnt = new Ctpvtnt(1, 2)
-val Ctpvtnt(extracted1i_Ctpvtnt, extracted2i_Ctpvtnt) = i_Ctpvtnt
-val Ctpvtnt(extracted1ch_Ctpvtnt, extracted2ch_Ctpvtnt) = ch_Ctpvtnt
-assert(1 == extracted1i_Ctpvtnt)
-assert(2 == extracted2i_Ctpvtnt)
-assert('a' == extracted1ch_Ctpvtnt)
-assert('b' == extracted2ch_Ctpvtnt)
-
-assert(2 == i_Ctpvtnt.a)
-assert('b' == ch_Ctpvtnt.a)
-assert(1 == i_Ctpvtnt.p1)
-assert(2 == i_Ctpvtnt.p2)
-assert('a' == ch_Ctpvtnt.p1)
-assert('b' == ch_Ctpvtnt.p2)
-
-
-val ch_Ctpvtnf = new Ctpvtnf('a', 'b')
-val i_Ctpvtnf = new Ctpvtnf(1, 2)
-val Ctpvtnf(extracted1i_Ctpvtnf, extracted2i_Ctpvtnf) = i_Ctpvtnf
-val Ctpvtnf(extracted1ch_Ctpvtnf, extracted2ch_Ctpvtnf) = ch_Ctpvtnf
-assert(1 == extracted1i_Ctpvtnf)
-assert(2 == extracted2i_Ctpvtnf)
-assert('a' == extracted1ch_Ctpvtnf)
-assert('b' == extracted2ch_Ctpvtnf)
-
-assert(2 == i_Ctpvtnf.a)
-assert('b' == ch_Ctpvtnf.a)
-assert(1 == i_Ctpvtnf.p1)
-assert('a' == ch_Ctpvtnf.p1)
-
-
-val ch_Ctpvfpvt = new Ctpvfpvt('a', 'b')
-val i_Ctpvfpvt = new Ctpvfpvt(1, 2)
-val Ctpvfpvt(extracted1i_Ctpvfpvt, extracted2i_Ctpvfpvt) = i_Ctpvfpvt
-val Ctpvfpvt(extracted1ch_Ctpvfpvt, extracted2ch_Ctpvfpvt) = ch_Ctpvfpvt
-assert(1 == extracted1i_Ctpvfpvt)
-assert(2 == extracted2i_Ctpvfpvt)
-assert('a' == extracted1ch_Ctpvfpvt)
-assert('b' == extracted2ch_Ctpvfpvt)
-
-assert(2 == i_Ctpvfpvt.p2)
-assert('b' == ch_Ctpvfpvt.p2)
-
-
-val ch_Ctpvfvt = new Ctpvfvt('a', 'b')
-val i_Ctpvfvt = new Ctpvfvt(1, 2)
-val Ctpvfvt(extracted1i_Ctpvfvt, extracted2i_Ctpvfvt) = i_Ctpvfvt
-val Ctpvfvt(extracted1ch_Ctpvfvt, extracted2ch_Ctpvfvt) = ch_Ctpvfvt
-assert(1 == extracted1i_Ctpvfvt)
-assert(2 == extracted2i_Ctpvfvt)
-assert('a' == extracted1ch_Ctpvfvt)
-assert('b' == extracted2ch_Ctpvfvt)
-
-assert(2 == i_Ctpvfvt.a)
-assert('b' == ch_Ctpvfvt.a)
-assert(2 == i_Ctpvfvt.p2)
-assert('b' == ch_Ctpvfvt.p2)
-
-
-val ch_Ctpvfnt = new Ctpvfnt('a', 'b')
-val i_Ctpvfnt = new Ctpvfnt(1, 2)
-val Ctpvfnt(extracted1i_Ctpvfnt, extracted2i_Ctpvfnt) = i_Ctpvfnt
-val Ctpvfnt(extracted1ch_Ctpvfnt, extracted2ch_Ctpvfnt) = ch_Ctpvfnt
-assert(1 == extracted1i_Ctpvfnt)
-assert(2 == extracted2i_Ctpvfnt)
-assert('a' == extracted1ch_Ctpvfnt)
-assert('b' == extracted2ch_Ctpvfnt)
-
-assert(2 == i_Ctpvfnt.a)
-assert('b' == ch_Ctpvfnt.a)
-assert(2 == i_Ctpvfnt.p2)
-assert('b' == ch_Ctpvfnt.p2)
-
-
-val ch_Ctvtpvt = new Ctvtpvt('a', 'b')
-val i_Ctvtpvt = new Ctvtpvt(1, 2)
-val Ctvtpvt(extracted1i_Ctvtpvt, extracted2i_Ctvtpvt) = i_Ctvtpvt
-val Ctvtpvt(extracted1ch_Ctvtpvt, extracted2ch_Ctvtpvt) = ch_Ctvtpvt
-assert(1 == extracted1i_Ctvtpvt)
-assert(2 == extracted2i_Ctvtpvt)
-assert('a' == extracted1ch_Ctvtpvt)
-assert('b' == extracted2ch_Ctvtpvt)
-
-assert(1 == i_Ctvtpvt.`a b`)
-assert('a' == ch_Ctvtpvt.`a b`)
-assert(1 == i_Ctvtpvt.p1)
-assert(2 == i_Ctvtpvt.p2)
-assert('a' == ch_Ctvtpvt.p1)
-assert('b' == ch_Ctvtpvt.p2)
-
-
-val ch_Ctvtpvf = new Ctvtpvf('a', 'b')
-val i_Ctvtpvf = new Ctvtpvf(1, 2)
-val Ctvtpvf(extracted1i_Ctvtpvf, extracted2i_Ctvtpvf) = i_Ctvtpvf
-val Ctvtpvf(extracted1ch_Ctvtpvf, extracted2ch_Ctvtpvf) = ch_Ctvtpvf
-assert(1 == extracted1i_Ctvtpvf)
-assert(2 == extracted2i_Ctvtpvf)
-assert('a' == extracted1ch_Ctvtpvf)
-assert('b' == extracted2ch_Ctvtpvf)
-
-assert(1 == i_Ctvtpvf.`a b`)
-assert('a' == ch_Ctvtpvf.`a b`)
-assert(1 == i_Ctvtpvf.p1)
-assert('a' == ch_Ctvtpvf.p1)
-
-
-val ch_Ctvtvt = new Ctvtvt('a', 'b')
-val i_Ctvtvt = new Ctvtvt(1, 2)
-val Ctvtvt(extracted1i_Ctvtvt, extracted2i_Ctvtvt) = i_Ctvtvt
-val Ctvtvt(extracted1ch_Ctvtvt, extracted2ch_Ctvtvt) = ch_Ctvtvt
-assert(1 == extracted1i_Ctvtvt)
-assert(2 == extracted2i_Ctvtvt)
-assert('a' == extracted1ch_Ctvtvt)
-assert('b' == extracted2ch_Ctvtvt)
-
-assert(1 == i_Ctvtvt.`a b`)
-assert(2 == i_Ctvtvt.a)
-assert('a' == ch_Ctvtvt.`a b`)
-assert('b' == ch_Ctvtvt.a)
-assert(1 == i_Ctvtvt.p1)
-assert(2 == i_Ctvtvt.p2)
-assert('a' == ch_Ctvtvt.p1)
-assert('b' == ch_Ctvtvt.p2)
-
-
-val ch_Ctvtvf = new Ctvtvf('a', 'b')
-val i_Ctvtvf = new Ctvtvf(1, 2)
-val Ctvtvf(extracted1i_Ctvtvf, extracted2i_Ctvtvf) = i_Ctvtvf
-val Ctvtvf(extracted1ch_Ctvtvf, extracted2ch_Ctvtvf) = ch_Ctvtvf
-assert(1 == extracted1i_Ctvtvf)
-assert(2 == extracted2i_Ctvtvf)
-assert('a' == extracted1ch_Ctvtvf)
-assert('b' == extracted2ch_Ctvtvf)
-
-assert(1 == i_Ctvtvf.`a b`)
-assert(2 == i_Ctvtvf.a)
-assert('a' == ch_Ctvtvf.`a b`)
-assert('b' == ch_Ctvtvf.a)
-assert(1 == i_Ctvtvf.p1)
-assert('a' == ch_Ctvtvf.p1)
-
-
-val ch_Ctvtnt = new Ctvtnt('a', 'b')
-val i_Ctvtnt = new Ctvtnt(1, 2)
-val Ctvtnt(extracted1i_Ctvtnt, extracted2i_Ctvtnt) = i_Ctvtnt
-val Ctvtnt(extracted1ch_Ctvtnt, extracted2ch_Ctvtnt) = ch_Ctvtnt
-assert(1 == extracted1i_Ctvtnt)
-assert(2 == extracted2i_Ctvtnt)
-assert('a' == extracted1ch_Ctvtnt)
-assert('b' == extracted2ch_Ctvtnt)
-
-assert(1 == i_Ctvtnt.`a b`)
-assert(2 == i_Ctvtnt.a)
-assert('a' == ch_Ctvtnt.`a b`)
-assert('b' == ch_Ctvtnt.a)
-assert(1 == i_Ctvtnt.p1)
-assert(2 == i_Ctvtnt.p2)
-assert('a' == ch_Ctvtnt.p1)
-assert('b' == ch_Ctvtnt.p2)
-
-
-val ch_Ctvtnf = new Ctvtnf('a', 'b')
-val i_Ctvtnf = new Ctvtnf(1, 2)
-val Ctvtnf(extracted1i_Ctvtnf, extracted2i_Ctvtnf) = i_Ctvtnf
-val Ctvtnf(extracted1ch_Ctvtnf, extracted2ch_Ctvtnf) = ch_Ctvtnf
-assert(1 == extracted1i_Ctvtnf)
-assert(2 == extracted2i_Ctvtnf)
-assert('a' == extracted1ch_Ctvtnf)
-assert('b' == extracted2ch_Ctvtnf)
-
-assert(1 == i_Ctvtnf.`a b`)
-assert(2 == i_Ctvtnf.a)
-assert('a' == ch_Ctvtnf.`a b`)
-assert('b' == ch_Ctvtnf.a)
-assert(1 == i_Ctvtnf.p1)
-assert('a' == ch_Ctvtnf.p1)
-
-
-val ch_Ctvfpvt = new Ctvfpvt('a', 'b')
-val i_Ctvfpvt = new Ctvfpvt(1, 2)
-val Ctvfpvt(extracted1i_Ctvfpvt, extracted2i_Ctvfpvt) = i_Ctvfpvt
-val Ctvfpvt(extracted1ch_Ctvfpvt, extracted2ch_Ctvfpvt) = ch_Ctvfpvt
-assert(1 == extracted1i_Ctvfpvt)
-assert(2 == extracted2i_Ctvfpvt)
-assert('a' == extracted1ch_Ctvfpvt)
-assert('b' == extracted2ch_Ctvfpvt)
-
-assert(1 == i_Ctvfpvt.`a b`)
-assert('a' == ch_Ctvfpvt.`a b`)
-assert(2 == i_Ctvfpvt.p2)
-assert('b' == ch_Ctvfpvt.p2)
-
-
-val ch_Ctvfvt = new Ctvfvt('a', 'b')
-val i_Ctvfvt = new Ctvfvt(1, 2)
-val Ctvfvt(extracted1i_Ctvfvt, extracted2i_Ctvfvt) = i_Ctvfvt
-val Ctvfvt(extracted1ch_Ctvfvt, extracted2ch_Ctvfvt) = ch_Ctvfvt
-assert(1 == extracted1i_Ctvfvt)
-assert(2 == extracted2i_Ctvfvt)
-assert('a' == extracted1ch_Ctvfvt)
-assert('b' == extracted2ch_Ctvfvt)
-
-assert(1 == i_Ctvfvt.`a b`)
-assert(2 == i_Ctvfvt.a)
-assert('a' == ch_Ctvfvt.`a b`)
-assert('b' == ch_Ctvfvt.a)
-assert(2 == i_Ctvfvt.p2)
-assert('b' == ch_Ctvfvt.p2)
-
-
-val ch_Ctvfnt = new Ctvfnt('a', 'b')
-val i_Ctvfnt = new Ctvfnt(1, 2)
-val Ctvfnt(extracted1i_Ctvfnt, extracted2i_Ctvfnt) = i_Ctvfnt
-val Ctvfnt(extracted1ch_Ctvfnt, extracted2ch_Ctvfnt) = ch_Ctvfnt
-assert(1 == extracted1i_Ctvfnt)
-assert(2 == extracted2i_Ctvfnt)
-assert('a' == extracted1ch_Ctvfnt)
-assert('b' == extracted2ch_Ctvfnt)
-
-assert(1 == i_Ctvfnt.`a b`)
-assert(2 == i_Ctvfnt.a)
-assert('a' == ch_Ctvfnt.`a b`)
-assert('b' == ch_Ctvfnt.a)
-assert(2 == i_Ctvfnt.p2)
-assert('b' == ch_Ctvfnt.p2)
-
-
-val ch_Ctntpvt = new Ctntpvt('a', 'b')
-val i_Ctntpvt = new Ctntpvt(1, 2)
-val Ctntpvt(extracted1i_Ctntpvt, extracted2i_Ctntpvt) = i_Ctntpvt
-val Ctntpvt(extracted1ch_Ctntpvt, extracted2ch_Ctntpvt) = ch_Ctntpvt
-assert(1 == extracted1i_Ctntpvt)
-assert(2 == extracted2i_Ctntpvt)
-assert('a' == extracted1ch_Ctntpvt)
-assert('b' == extracted2ch_Ctntpvt)
-
-assert(1 == i_Ctntpvt.`a b`)
-assert('a' == ch_Ctntpvt.`a b`)
-assert(1 == i_Ctntpvt.p1)
-assert(2 == i_Ctntpvt.p2)
-assert('a' == ch_Ctntpvt.p1)
-assert('b' == ch_Ctntpvt.p2)
-
-
-val ch_Ctntpvf = new Ctntpvf('a', 'b')
-val i_Ctntpvf = new Ctntpvf(1, 2)
-val Ctntpvf(extracted1i_Ctntpvf, extracted2i_Ctntpvf) = i_Ctntpvf
-val Ctntpvf(extracted1ch_Ctntpvf, extracted2ch_Ctntpvf) = ch_Ctntpvf
-assert(1 == extracted1i_Ctntpvf)
-assert(2 == extracted2i_Ctntpvf)
-assert('a' == extracted1ch_Ctntpvf)
-assert('b' == extracted2ch_Ctntpvf)
-
-assert(1 == i_Ctntpvf.`a b`)
-assert('a' == ch_Ctntpvf.`a b`)
-assert(1 == i_Ctntpvf.p1)
-assert('a' == ch_Ctntpvf.p1)
-
-
-val ch_Ctntvt = new Ctntvt('a', 'b')
-val i_Ctntvt = new Ctntvt(1, 2)
-val Ctntvt(extracted1i_Ctntvt, extracted2i_Ctntvt) = i_Ctntvt
-val Ctntvt(extracted1ch_Ctntvt, extracted2ch_Ctntvt) = ch_Ctntvt
-assert(1 == extracted1i_Ctntvt)
-assert(2 == extracted2i_Ctntvt)
-assert('a' == extracted1ch_Ctntvt)
-assert('b' == extracted2ch_Ctntvt)
-
-assert(1 == i_Ctntvt.`a b`)
-assert(2 == i_Ctntvt.a)
-assert('a' == ch_Ctntvt.`a b`)
-assert('b' == ch_Ctntvt.a)
-assert(1 == i_Ctntvt.p1)
-assert(2 == i_Ctntvt.p2)
-assert('a' == ch_Ctntvt.p1)
-assert('b' == ch_Ctntvt.p2)
-
-
-val ch_Ctntvf = new Ctntvf('a', 'b')
-val i_Ctntvf = new Ctntvf(1, 2)
-val Ctntvf(extracted1i_Ctntvf, extracted2i_Ctntvf) = i_Ctntvf
-val Ctntvf(extracted1ch_Ctntvf, extracted2ch_Ctntvf) = ch_Ctntvf
-assert(1 == extracted1i_Ctntvf)
-assert(2 == extracted2i_Ctntvf)
-assert('a' == extracted1ch_Ctntvf)
-assert('b' == extracted2ch_Ctntvf)
-
-assert(1 == i_Ctntvf.`a b`)
-assert(2 == i_Ctntvf.a)
-assert('a' == ch_Ctntvf.`a b`)
-assert('b' == ch_Ctntvf.a)
-assert(1 == i_Ctntvf.p1)
-assert('a' == ch_Ctntvf.p1)
-
-
-val ch_Ctntnt = new Ctntnt('a', 'b')
-val i_Ctntnt = new Ctntnt(1, 2)
-val Ctntnt(extracted1i_Ctntnt, extracted2i_Ctntnt) = i_Ctntnt
-val Ctntnt(extracted1ch_Ctntnt, extracted2ch_Ctntnt) = ch_Ctntnt
-assert(1 == extracted1i_Ctntnt)
-assert(2 == extracted2i_Ctntnt)
-assert('a' == extracted1ch_Ctntnt)
-assert('b' == extracted2ch_Ctntnt)
-
-assert(1 == i_Ctntnt.`a b`)
-assert(2 == i_Ctntnt.a)
-assert('a' == ch_Ctntnt.`a b`)
-assert('b' == ch_Ctntnt.a)
-assert(1 == i_Ctntnt.p1)
-assert(2 == i_Ctntnt.p2)
-assert('a' == ch_Ctntnt.p1)
-assert('b' == ch_Ctntnt.p2)
-
-
-val ch_Ctntnf = new Ctntnf('a', 'b')
-val i_Ctntnf = new Ctntnf(1, 2)
-val Ctntnf(extracted1i_Ctntnf, extracted2i_Ctntnf) = i_Ctntnf
-val Ctntnf(extracted1ch_Ctntnf, extracted2ch_Ctntnf) = ch_Ctntnf
-assert(1 == extracted1i_Ctntnf)
-assert(2 == extracted2i_Ctntnf)
-assert('a' == extracted1ch_Ctntnf)
-assert('b' == extracted2ch_Ctntnf)
-
-assert(1 == i_Ctntnf.`a b`)
-assert(2 == i_Ctntnf.a)
-assert('a' == ch_Ctntnf.`a b`)
-assert('b' == ch_Ctntnf.a)
-assert(1 == i_Ctntnf.p1)
-assert('a' == ch_Ctntnf.p1)
-
-
-val ch_Ctnfpvt = new Ctnfpvt('a', 'b')
-val i_Ctnfpvt = new Ctnfpvt(1, 2)
-val Ctnfpvt(extracted1i_Ctnfpvt, extracted2i_Ctnfpvt) = i_Ctnfpvt
-val Ctnfpvt(extracted1ch_Ctnfpvt, extracted2ch_Ctnfpvt) = ch_Ctnfpvt
-assert(1 == extracted1i_Ctnfpvt)
-assert(2 == extracted2i_Ctnfpvt)
-assert('a' == extracted1ch_Ctnfpvt)
-assert('b' == extracted2ch_Ctnfpvt)
-
-assert(1 == i_Ctnfpvt.`a b`)
-assert('a' == ch_Ctnfpvt.`a b`)
-assert(2 == i_Ctnfpvt.p2)
-assert('b' == ch_Ctnfpvt.p2)
-
-
-val ch_Ctnfvt = new Ctnfvt('a', 'b')
-val i_Ctnfvt = new Ctnfvt(1, 2)
-val Ctnfvt(extracted1i_Ctnfvt, extracted2i_Ctnfvt) = i_Ctnfvt
-val Ctnfvt(extracted1ch_Ctnfvt, extracted2ch_Ctnfvt) = ch_Ctnfvt
-assert(1 == extracted1i_Ctnfvt)
-assert(2 == extracted2i_Ctnfvt)
-assert('a' == extracted1ch_Ctnfvt)
-assert('b' == extracted2ch_Ctnfvt)
-
-assert(1 == i_Ctnfvt.`a b`)
-assert(2 == i_Ctnfvt.a)
-assert('a' == ch_Ctnfvt.`a b`)
-assert('b' == ch_Ctnfvt.a)
-assert(2 == i_Ctnfvt.p2)
-assert('b' == ch_Ctnfvt.p2)
-
-
-val ch_Ctnfnt = new Ctnfnt('a', 'b')
-val i_Ctnfnt = new Ctnfnt(1, 2)
-val Ctnfnt(extracted1i_Ctnfnt, extracted2i_Ctnfnt) = i_Ctnfnt
-val Ctnfnt(extracted1ch_Ctnfnt, extracted2ch_Ctnfnt) = ch_Ctnfnt
-assert(1 == extracted1i_Ctnfnt)
-assert(2 == extracted2i_Ctnfnt)
-assert('a' == extracted1ch_Ctnfnt)
-assert('b' == extracted2ch_Ctnfnt)
-
-assert(1 == i_Ctnfnt.`a b`)
-assert(2 == i_Ctnfnt.a)
-assert('a' == ch_Ctnfnt.`a b`)
-assert('b' == ch_Ctnfnt.a)
-assert(2 == i_Ctnfnt.p2)
-assert('b' == ch_Ctnfnt.p2)
-
-
-val ch_Cfpvtpvt = new Cfpvtpvt('a', 'b')
-val i_Cfpvtpvt = new Cfpvtpvt(1, 2)
-val Cfpvtpvt(extracted1i_Cfpvtpvt, extracted2i_Cfpvtpvt) = i_Cfpvtpvt
-val Cfpvtpvt(extracted1ch_Cfpvtpvt, extracted2ch_Cfpvtpvt) = ch_Cfpvtpvt
-assert(1 == extracted1i_Cfpvtpvt)
-assert(2 == extracted2i_Cfpvtpvt)
-assert('a' == extracted1ch_Cfpvtpvt)
-assert('b' == extracted2ch_Cfpvtpvt)
-
-assert(1 == i_Cfpvtpvt.p1)
-assert(2 == i_Cfpvtpvt.p2)
-assert('a' == ch_Cfpvtpvt.p1)
-assert('b' == ch_Cfpvtpvt.p2)
-
-
-val ch_Cfpvtpvf = new Cfpvtpvf('a', 'b')
-val i_Cfpvtpvf = new Cfpvtpvf(1, 2)
-val Cfpvtpvf(extracted1i_Cfpvtpvf, extracted2i_Cfpvtpvf) = i_Cfpvtpvf
-val Cfpvtpvf(extracted1ch_Cfpvtpvf, extracted2ch_Cfpvtpvf) = ch_Cfpvtpvf
-assert(1 == extracted1i_Cfpvtpvf)
-assert(2 == extracted2i_Cfpvtpvf)
-assert('a' == extracted1ch_Cfpvtpvf)
-assert('b' == extracted2ch_Cfpvtpvf)
-
-assert(1 == i_Cfpvtpvf.p1)
-assert('a' == ch_Cfpvtpvf.p1)
-
-
-val ch_Cfpvtvt = new Cfpvtvt('a', 'b')
-val i_Cfpvtvt = new Cfpvtvt(1, 2)
-val Cfpvtvt(extracted1i_Cfpvtvt, extracted2i_Cfpvtvt) = i_Cfpvtvt
-val Cfpvtvt(extracted1ch_Cfpvtvt, extracted2ch_Cfpvtvt) = ch_Cfpvtvt
-assert(1 == extracted1i_Cfpvtvt)
-assert(2 == extracted2i_Cfpvtvt)
-assert('a' == extracted1ch_Cfpvtvt)
-assert('b' == extracted2ch_Cfpvtvt)
-
-assert(2 == i_Cfpvtvt.a)
-assert('b' == ch_Cfpvtvt.a)
-assert(1 == i_Cfpvtvt.p1)
-assert(2 == i_Cfpvtvt.p2)
-assert('a' == ch_Cfpvtvt.p1)
-assert('b' == ch_Cfpvtvt.p2)
-
-
-val ch_Cfpvtvf = new Cfpvtvf('a', 'b')
-val i_Cfpvtvf = new Cfpvtvf(1, 2)
-val Cfpvtvf(extracted1i_Cfpvtvf, extracted2i_Cfpvtvf) = i_Cfpvtvf
-val Cfpvtvf(extracted1ch_Cfpvtvf, extracted2ch_Cfpvtvf) = ch_Cfpvtvf
-assert(1 == extracted1i_Cfpvtvf)
-assert(2 == extracted2i_Cfpvtvf)
-assert('a' == extracted1ch_Cfpvtvf)
-assert('b' == extracted2ch_Cfpvtvf)
-
-assert(2 == i_Cfpvtvf.a)
-assert('b' == ch_Cfpvtvf.a)
-assert(1 == i_Cfpvtvf.p1)
-assert('a' == ch_Cfpvtvf.p1)
-
-
-val ch_Cfpvtnt = new Cfpvtnt('a', 'b')
-val i_Cfpvtnt = new Cfpvtnt(1, 2)
-val Cfpvtnt(extracted1i_Cfpvtnt, extracted2i_Cfpvtnt) = i_Cfpvtnt
-val Cfpvtnt(extracted1ch_Cfpvtnt, extracted2ch_Cfpvtnt) = ch_Cfpvtnt
-assert(1 == extracted1i_Cfpvtnt)
-assert(2 == extracted2i_Cfpvtnt)
-assert('a' == extracted1ch_Cfpvtnt)
-assert('b' == extracted2ch_Cfpvtnt)
-
-assert(2 == i_Cfpvtnt.a)
-assert('b' == ch_Cfpvtnt.a)
-assert(1 == i_Cfpvtnt.p1)
-assert(2 == i_Cfpvtnt.p2)
-assert('a' == ch_Cfpvtnt.p1)
-assert('b' == ch_Cfpvtnt.p2)
-
-
-val ch_Cfpvtnf = new Cfpvtnf('a', 'b')
-val i_Cfpvtnf = new Cfpvtnf(1, 2)
-val Cfpvtnf(extracted1i_Cfpvtnf, extracted2i_Cfpvtnf) = i_Cfpvtnf
-val Cfpvtnf(extracted1ch_Cfpvtnf, extracted2ch_Cfpvtnf) = ch_Cfpvtnf
-assert(1 == extracted1i_Cfpvtnf)
-assert(2 == extracted2i_Cfpvtnf)
-assert('a' == extracted1ch_Cfpvtnf)
-assert('b' == extracted2ch_Cfpvtnf)
-
-assert(2 == i_Cfpvtnf.a)
-assert('b' == ch_Cfpvtnf.a)
-assert(1 == i_Cfpvtnf.p1)
-assert('a' == ch_Cfpvtnf.p1)
-
-
-val ch_Cfpvfpvt = new Cfpvfpvt('a', 'b')
-val i_Cfpvfpvt = new Cfpvfpvt(1, 2)
-val Cfpvfpvt(extracted1i_Cfpvfpvt, extracted2i_Cfpvfpvt) = i_Cfpvfpvt
-val Cfpvfpvt(extracted1ch_Cfpvfpvt, extracted2ch_Cfpvfpvt) = ch_Cfpvfpvt
-assert(1 == extracted1i_Cfpvfpvt)
-assert(2 == extracted2i_Cfpvfpvt)
-assert('a' == extracted1ch_Cfpvfpvt)
-assert('b' == extracted2ch_Cfpvfpvt)
-
-assert(2 == i_Cfpvfpvt.p2)
-assert('b' == ch_Cfpvfpvt.p2)
-
-
-val ch_Cfpvfpvf = new Cfpvfpvf('a', 'b')
-val i_Cfpvfpvf = new Cfpvfpvf(1, 2)
-val Cfpvfpvf(extracted1i_Cfpvfpvf, extracted2i_Cfpvfpvf) = i_Cfpvfpvf
-val Cfpvfpvf(extracted1ch_Cfpvfpvf, extracted2ch_Cfpvfpvf) = ch_Cfpvfpvf
-assert(1 == extracted1i_Cfpvfpvf)
-assert(2 == extracted2i_Cfpvfpvf)
-assert('a' == extracted1ch_Cfpvfpvf)
-assert('b' == extracted2ch_Cfpvfpvf)
-
-
-
-val ch_Cfpvfvt = new Cfpvfvt('a', 'b')
-val i_Cfpvfvt = new Cfpvfvt(1, 2)
-val Cfpvfvt(extracted1i_Cfpvfvt, extracted2i_Cfpvfvt) = i_Cfpvfvt
-val Cfpvfvt(extracted1ch_Cfpvfvt, extracted2ch_Cfpvfvt) = ch_Cfpvfvt
-assert(1 == extracted1i_Cfpvfvt)
-assert(2 == extracted2i_Cfpvfvt)
-assert('a' == extracted1ch_Cfpvfvt)
-assert('b' == extracted2ch_Cfpvfvt)
-
-assert(2 == i_Cfpvfvt.a)
-assert('b' == ch_Cfpvfvt.a)
-assert(2 == i_Cfpvfvt.p2)
-assert('b' == ch_Cfpvfvt.p2)
-
-
-val ch_Cfpvfvf = new Cfpvfvf('a', 'b')
-val i_Cfpvfvf = new Cfpvfvf(1, 2)
-val Cfpvfvf(extracted1i_Cfpvfvf, extracted2i_Cfpvfvf) = i_Cfpvfvf
-val Cfpvfvf(extracted1ch_Cfpvfvf, extracted2ch_Cfpvfvf) = ch_Cfpvfvf
-assert(1 == extracted1i_Cfpvfvf)
-assert(2 == extracted2i_Cfpvfvf)
-assert('a' == extracted1ch_Cfpvfvf)
-assert('b' == extracted2ch_Cfpvfvf)
-
-assert(2 == i_Cfpvfvf.a)
-assert('b' == ch_Cfpvfvf.a)
-
-
-val ch_Cfpvfnt = new Cfpvfnt('a', 'b')
-val i_Cfpvfnt = new Cfpvfnt(1, 2)
-val Cfpvfnt(extracted1i_Cfpvfnt, extracted2i_Cfpvfnt) = i_Cfpvfnt
-val Cfpvfnt(extracted1ch_Cfpvfnt, extracted2ch_Cfpvfnt) = ch_Cfpvfnt
-assert(1 == extracted1i_Cfpvfnt)
-assert(2 == extracted2i_Cfpvfnt)
-assert('a' == extracted1ch_Cfpvfnt)
-assert('b' == extracted2ch_Cfpvfnt)
-
-assert(2 == i_Cfpvfnt.a)
-assert('b' == ch_Cfpvfnt.a)
-assert(2 == i_Cfpvfnt.p2)
-assert('b' == ch_Cfpvfnt.p2)
-
-
-val ch_Cfpvfnf = new Cfpvfnf('a', 'b')
-val i_Cfpvfnf = new Cfpvfnf(1, 2)
-val Cfpvfnf(extracted1i_Cfpvfnf, extracted2i_Cfpvfnf) = i_Cfpvfnf
-val Cfpvfnf(extracted1ch_Cfpvfnf, extracted2ch_Cfpvfnf) = ch_Cfpvfnf
-assert(1 == extracted1i_Cfpvfnf)
-assert(2 == extracted2i_Cfpvfnf)
-assert('a' == extracted1ch_Cfpvfnf)
-assert('b' == extracted2ch_Cfpvfnf)
-
-assert(2 == i_Cfpvfnf.a)
-assert('b' == ch_Cfpvfnf.a)
-
-
-val ch_Cfvtpvt = new Cfvtpvt('a', 'b')
-val i_Cfvtpvt = new Cfvtpvt(1, 2)
-val Cfvtpvt(extracted1i_Cfvtpvt, extracted2i_Cfvtpvt) = i_Cfvtpvt
-val Cfvtpvt(extracted1ch_Cfvtpvt, extracted2ch_Cfvtpvt) = ch_Cfvtpvt
-assert(1 == extracted1i_Cfvtpvt)
-assert(2 == extracted2i_Cfvtpvt)
-assert('a' == extracted1ch_Cfvtpvt)
-assert('b' == extracted2ch_Cfvtpvt)
-
-assert(1 == i_Cfvtpvt.`a b`)
-assert('a' == ch_Cfvtpvt.`a b`)
-assert(1 == i_Cfvtpvt.p1)
-assert(2 == i_Cfvtpvt.p2)
-assert('a' == ch_Cfvtpvt.p1)
-assert('b' == ch_Cfvtpvt.p2)
-
-
-val ch_Cfvtpvf = new Cfvtpvf('a', 'b')
-val i_Cfvtpvf = new Cfvtpvf(1, 2)
-val Cfvtpvf(extracted1i_Cfvtpvf, extracted2i_Cfvtpvf) = i_Cfvtpvf
-val Cfvtpvf(extracted1ch_Cfvtpvf, extracted2ch_Cfvtpvf) = ch_Cfvtpvf
-assert(1 == extracted1i_Cfvtpvf)
-assert(2 == extracted2i_Cfvtpvf)
-assert('a' == extracted1ch_Cfvtpvf)
-assert('b' == extracted2ch_Cfvtpvf)
-
-assert(1 == i_Cfvtpvf.`a b`)
-assert('a' == ch_Cfvtpvf.`a b`)
-assert(1 == i_Cfvtpvf.p1)
-assert('a' == ch_Cfvtpvf.p1)
-
-
-val ch_Cfvtvt = new Cfvtvt('a', 'b')
-val i_Cfvtvt = new Cfvtvt(1, 2)
-val Cfvtvt(extracted1i_Cfvtvt, extracted2i_Cfvtvt) = i_Cfvtvt
-val Cfvtvt(extracted1ch_Cfvtvt, extracted2ch_Cfvtvt) = ch_Cfvtvt
-assert(1 == extracted1i_Cfvtvt)
-assert(2 == extracted2i_Cfvtvt)
-assert('a' == extracted1ch_Cfvtvt)
-assert('b' == extracted2ch_Cfvtvt)
-
-assert(1 == i_Cfvtvt.`a b`)
-assert(2 == i_Cfvtvt.a)
-assert('a' == ch_Cfvtvt.`a b`)
-assert('b' == ch_Cfvtvt.a)
-assert(1 == i_Cfvtvt.p1)
-assert(2 == i_Cfvtvt.p2)
-assert('a' == ch_Cfvtvt.p1)
-assert('b' == ch_Cfvtvt.p2)
-
-
-val ch_Cfvtvf = new Cfvtvf('a', 'b')
-val i_Cfvtvf = new Cfvtvf(1, 2)
-val Cfvtvf(extracted1i_Cfvtvf, extracted2i_Cfvtvf) = i_Cfvtvf
-val Cfvtvf(extracted1ch_Cfvtvf, extracted2ch_Cfvtvf) = ch_Cfvtvf
-assert(1 == extracted1i_Cfvtvf)
-assert(2 == extracted2i_Cfvtvf)
-assert('a' == extracted1ch_Cfvtvf)
-assert('b' == extracted2ch_Cfvtvf)
-
-assert(1 == i_Cfvtvf.`a b`)
-assert(2 == i_Cfvtvf.a)
-assert('a' == ch_Cfvtvf.`a b`)
-assert('b' == ch_Cfvtvf.a)
-assert(1 == i_Cfvtvf.p1)
-assert('a' == ch_Cfvtvf.p1)
-
-
-val ch_Cfvtnt = new Cfvtnt('a', 'b')
-val i_Cfvtnt = new Cfvtnt(1, 2)
-val Cfvtnt(extracted1i_Cfvtnt, extracted2i_Cfvtnt) = i_Cfvtnt
-val Cfvtnt(extracted1ch_Cfvtnt, extracted2ch_Cfvtnt) = ch_Cfvtnt
-assert(1 == extracted1i_Cfvtnt)
-assert(2 == extracted2i_Cfvtnt)
-assert('a' == extracted1ch_Cfvtnt)
-assert('b' == extracted2ch_Cfvtnt)
-
-assert(1 == i_Cfvtnt.`a b`)
-assert(2 == i_Cfvtnt.a)
-assert('a' == ch_Cfvtnt.`a b`)
-assert('b' == ch_Cfvtnt.a)
-assert(1 == i_Cfvtnt.p1)
-assert(2 == i_Cfvtnt.p2)
-assert('a' == ch_Cfvtnt.p1)
-assert('b' == ch_Cfvtnt.p2)
-
-
-val ch_Cfvtnf = new Cfvtnf('a', 'b')
-val i_Cfvtnf = new Cfvtnf(1, 2)
-val Cfvtnf(extracted1i_Cfvtnf, extracted2i_Cfvtnf) = i_Cfvtnf
-val Cfvtnf(extracted1ch_Cfvtnf, extracted2ch_Cfvtnf) = ch_Cfvtnf
-assert(1 == extracted1i_Cfvtnf)
-assert(2 == extracted2i_Cfvtnf)
-assert('a' == extracted1ch_Cfvtnf)
-assert('b' == extracted2ch_Cfvtnf)
-
-assert(1 == i_Cfvtnf.`a b`)
-assert(2 == i_Cfvtnf.a)
-assert('a' == ch_Cfvtnf.`a b`)
-assert('b' == ch_Cfvtnf.a)
-assert(1 == i_Cfvtnf.p1)
-assert('a' == ch_Cfvtnf.p1)
-
-
-val ch_Cfvfpvt = new Cfvfpvt('a', 'b')
-val i_Cfvfpvt = new Cfvfpvt(1, 2)
-val Cfvfpvt(extracted1i_Cfvfpvt, extracted2i_Cfvfpvt) = i_Cfvfpvt
-val Cfvfpvt(extracted1ch_Cfvfpvt, extracted2ch_Cfvfpvt) = ch_Cfvfpvt
-assert(1 == extracted1i_Cfvfpvt)
-assert(2 == extracted2i_Cfvfpvt)
-assert('a' == extracted1ch_Cfvfpvt)
-assert('b' == extracted2ch_Cfvfpvt)
-
-assert(1 == i_Cfvfpvt.`a b`)
-assert('a' == ch_Cfvfpvt.`a b`)
-assert(2 == i_Cfvfpvt.p2)
-assert('b' == ch_Cfvfpvt.p2)
-
-
-val ch_Cfvfpvf = new Cfvfpvf('a', 'b')
-val i_Cfvfpvf = new Cfvfpvf(1, 2)
-val Cfvfpvf(extracted1i_Cfvfpvf, extracted2i_Cfvfpvf) = i_Cfvfpvf
-val Cfvfpvf(extracted1ch_Cfvfpvf, extracted2ch_Cfvfpvf) = ch_Cfvfpvf
-assert(1 == extracted1i_Cfvfpvf)
-assert(2 == extracted2i_Cfvfpvf)
-assert('a' == extracted1ch_Cfvfpvf)
-assert('b' == extracted2ch_Cfvfpvf)
-
-assert(1 == i_Cfvfpvf.`a b`)
-assert('a' == ch_Cfvfpvf.`a b`)
-
-
-val ch_Cfvfvt = new Cfvfvt('a', 'b')
-val i_Cfvfvt = new Cfvfvt(1, 2)
-val Cfvfvt(extracted1i_Cfvfvt, extracted2i_Cfvfvt) = i_Cfvfvt
-val Cfvfvt(extracted1ch_Cfvfvt, extracted2ch_Cfvfvt) = ch_Cfvfvt
-assert(1 == extracted1i_Cfvfvt)
-assert(2 == extracted2i_Cfvfvt)
-assert('a' == extracted1ch_Cfvfvt)
-assert('b' == extracted2ch_Cfvfvt)
-
-assert(1 == i_Cfvfvt.`a b`)
-assert(2 == i_Cfvfvt.a)
-assert('a' == ch_Cfvfvt.`a b`)
-assert('b' == ch_Cfvfvt.a)
-assert(2 == i_Cfvfvt.p2)
-assert('b' == ch_Cfvfvt.p2)
-
-
-val ch_Cfvfvf = new Cfvfvf('a', 'b')
-val i_Cfvfvf = new Cfvfvf(1, 2)
-val Cfvfvf(extracted1i_Cfvfvf, extracted2i_Cfvfvf) = i_Cfvfvf
-val Cfvfvf(extracted1ch_Cfvfvf, extracted2ch_Cfvfvf) = ch_Cfvfvf
-assert(1 == extracted1i_Cfvfvf)
-assert(2 == extracted2i_Cfvfvf)
-assert('a' == extracted1ch_Cfvfvf)
-assert('b' == extracted2ch_Cfvfvf)
-
-assert(1 == i_Cfvfvf.`a b`)
-assert(2 == i_Cfvfvf.a)
-assert('a' == ch_Cfvfvf.`a b`)
-assert('b' == ch_Cfvfvf.a)
-
-
-val ch_Cfvfnt = new Cfvfnt('a', 'b')
-val i_Cfvfnt = new Cfvfnt(1, 2)
-val Cfvfnt(extracted1i_Cfvfnt, extracted2i_Cfvfnt) = i_Cfvfnt
-val Cfvfnt(extracted1ch_Cfvfnt, extracted2ch_Cfvfnt) = ch_Cfvfnt
-assert(1 == extracted1i_Cfvfnt)
-assert(2 == extracted2i_Cfvfnt)
-assert('a' == extracted1ch_Cfvfnt)
-assert('b' == extracted2ch_Cfvfnt)
-
-assert(1 == i_Cfvfnt.`a b`)
-assert(2 == i_Cfvfnt.a)
-assert('a' == ch_Cfvfnt.`a b`)
-assert('b' == ch_Cfvfnt.a)
-assert(2 == i_Cfvfnt.p2)
-assert('b' == ch_Cfvfnt.p2)
-
-
-val ch_Cfvfnf = new Cfvfnf('a', 'b')
-val i_Cfvfnf = new Cfvfnf(1, 2)
-val Cfvfnf(extracted1i_Cfvfnf, extracted2i_Cfvfnf) = i_Cfvfnf
-val Cfvfnf(extracted1ch_Cfvfnf, extracted2ch_Cfvfnf) = ch_Cfvfnf
-assert(1 == extracted1i_Cfvfnf)
-assert(2 == extracted2i_Cfvfnf)
-assert('a' == extracted1ch_Cfvfnf)
-assert('b' == extracted2ch_Cfvfnf)
-
-assert(1 == i_Cfvfnf.`a b`)
-assert(2 == i_Cfvfnf.a)
-assert('a' == ch_Cfvfnf.`a b`)
-assert('b' == ch_Cfvfnf.a)
-
-
-val ch_Cfntpvt = new Cfntpvt('a', 'b')
-val i_Cfntpvt = new Cfntpvt(1, 2)
-val Cfntpvt(extracted1i_Cfntpvt, extracted2i_Cfntpvt) = i_Cfntpvt
-val Cfntpvt(extracted1ch_Cfntpvt, extracted2ch_Cfntpvt) = ch_Cfntpvt
-assert(1 == extracted1i_Cfntpvt)
-assert(2 == extracted2i_Cfntpvt)
-assert('a' == extracted1ch_Cfntpvt)
-assert('b' == extracted2ch_Cfntpvt)
-
-assert(1 == i_Cfntpvt.`a b`)
-assert('a' == ch_Cfntpvt.`a b`)
-assert(1 == i_Cfntpvt.p1)
-assert(2 == i_Cfntpvt.p2)
-assert('a' == ch_Cfntpvt.p1)
-assert('b' == ch_Cfntpvt.p2)
-
-
-val ch_Cfntpvf = new Cfntpvf('a', 'b')
-val i_Cfntpvf = new Cfntpvf(1, 2)
-val Cfntpvf(extracted1i_Cfntpvf, extracted2i_Cfntpvf) = i_Cfntpvf
-val Cfntpvf(extracted1ch_Cfntpvf, extracted2ch_Cfntpvf) = ch_Cfntpvf
-assert(1 == extracted1i_Cfntpvf)
-assert(2 == extracted2i_Cfntpvf)
-assert('a' == extracted1ch_Cfntpvf)
-assert('b' == extracted2ch_Cfntpvf)
-
-assert(1 == i_Cfntpvf.`a b`)
-assert('a' == ch_Cfntpvf.`a b`)
-assert(1 == i_Cfntpvf.p1)
-assert('a' == ch_Cfntpvf.p1)
-
-
-val ch_Cfntvt = new Cfntvt('a', 'b')
-val i_Cfntvt = new Cfntvt(1, 2)
-val Cfntvt(extracted1i_Cfntvt, extracted2i_Cfntvt) = i_Cfntvt
-val Cfntvt(extracted1ch_Cfntvt, extracted2ch_Cfntvt) = ch_Cfntvt
-assert(1 == extracted1i_Cfntvt)
-assert(2 == extracted2i_Cfntvt)
-assert('a' == extracted1ch_Cfntvt)
-assert('b' == extracted2ch_Cfntvt)
-
-assert(1 == i_Cfntvt.`a b`)
-assert(2 == i_Cfntvt.a)
-assert('a' == ch_Cfntvt.`a b`)
-assert('b' == ch_Cfntvt.a)
-assert(1 == i_Cfntvt.p1)
-assert(2 == i_Cfntvt.p2)
-assert('a' == ch_Cfntvt.p1)
-assert('b' == ch_Cfntvt.p2)
-
-
-val ch_Cfntvf = new Cfntvf('a', 'b')
-val i_Cfntvf = new Cfntvf(1, 2)
-val Cfntvf(extracted1i_Cfntvf, extracted2i_Cfntvf) = i_Cfntvf
-val Cfntvf(extracted1ch_Cfntvf, extracted2ch_Cfntvf) = ch_Cfntvf
-assert(1 == extracted1i_Cfntvf)
-assert(2 == extracted2i_Cfntvf)
-assert('a' == extracted1ch_Cfntvf)
-assert('b' == extracted2ch_Cfntvf)
-
-assert(1 == i_Cfntvf.`a b`)
-assert(2 == i_Cfntvf.a)
-assert('a' == ch_Cfntvf.`a b`)
-assert('b' == ch_Cfntvf.a)
-assert(1 == i_Cfntvf.p1)
-assert('a' == ch_Cfntvf.p1)
-
-
-val ch_Cfntnt = new Cfntnt('a', 'b')
-val i_Cfntnt = new Cfntnt(1, 2)
-val Cfntnt(extracted1i_Cfntnt, extracted2i_Cfntnt) = i_Cfntnt
-val Cfntnt(extracted1ch_Cfntnt, extracted2ch_Cfntnt) = ch_Cfntnt
-assert(1 == extracted1i_Cfntnt)
-assert(2 == extracted2i_Cfntnt)
-assert('a' == extracted1ch_Cfntnt)
-assert('b' == extracted2ch_Cfntnt)
-
-assert(1 == i_Cfntnt.`a b`)
-assert(2 == i_Cfntnt.a)
-assert('a' == ch_Cfntnt.`a b`)
-assert('b' == ch_Cfntnt.a)
-assert(1 == i_Cfntnt.p1)
-assert(2 == i_Cfntnt.p2)
-assert('a' == ch_Cfntnt.p1)
-assert('b' == ch_Cfntnt.p2)
-
-
-val ch_Cfntnf = new Cfntnf('a', 'b')
-val i_Cfntnf = new Cfntnf(1, 2)
-val Cfntnf(extracted1i_Cfntnf, extracted2i_Cfntnf) = i_Cfntnf
-val Cfntnf(extracted1ch_Cfntnf, extracted2ch_Cfntnf) = ch_Cfntnf
-assert(1 == extracted1i_Cfntnf)
-assert(2 == extracted2i_Cfntnf)
-assert('a' == extracted1ch_Cfntnf)
-assert('b' == extracted2ch_Cfntnf)
-
-assert(1 == i_Cfntnf.`a b`)
-assert(2 == i_Cfntnf.a)
-assert('a' == ch_Cfntnf.`a b`)
-assert('b' == ch_Cfntnf.a)
-assert(1 == i_Cfntnf.p1)
-assert('a' == ch_Cfntnf.p1)
-
-
-val ch_Cfnfpvt = new Cfnfpvt('a', 'b')
-val i_Cfnfpvt = new Cfnfpvt(1, 2)
-val Cfnfpvt(extracted1i_Cfnfpvt, extracted2i_Cfnfpvt) = i_Cfnfpvt
-val Cfnfpvt(extracted1ch_Cfnfpvt, extracted2ch_Cfnfpvt) = ch_Cfnfpvt
-assert(1 == extracted1i_Cfnfpvt)
-assert(2 == extracted2i_Cfnfpvt)
-assert('a' == extracted1ch_Cfnfpvt)
-assert('b' == extracted2ch_Cfnfpvt)
-
-assert(1 == i_Cfnfpvt.`a b`)
-assert('a' == ch_Cfnfpvt.`a b`)
-assert(2 == i_Cfnfpvt.p2)
-assert('b' == ch_Cfnfpvt.p2)
-
-
-val ch_Cfnfpvf = new Cfnfpvf('a', 'b')
-val i_Cfnfpvf = new Cfnfpvf(1, 2)
-val Cfnfpvf(extracted1i_Cfnfpvf, extracted2i_Cfnfpvf) = i_Cfnfpvf
-val Cfnfpvf(extracted1ch_Cfnfpvf, extracted2ch_Cfnfpvf) = ch_Cfnfpvf
-assert(1 == extracted1i_Cfnfpvf)
-assert(2 == extracted2i_Cfnfpvf)
-assert('a' == extracted1ch_Cfnfpvf)
-assert('b' == extracted2ch_Cfnfpvf)
-
-assert(1 == i_Cfnfpvf.`a b`)
-assert('a' == ch_Cfnfpvf.`a b`)
-
-
-val ch_Cfnfvt = new Cfnfvt('a', 'b')
-val i_Cfnfvt = new Cfnfvt(1, 2)
-val Cfnfvt(extracted1i_Cfnfvt, extracted2i_Cfnfvt) = i_Cfnfvt
-val Cfnfvt(extracted1ch_Cfnfvt, extracted2ch_Cfnfvt) = ch_Cfnfvt
-assert(1 == extracted1i_Cfnfvt)
-assert(2 == extracted2i_Cfnfvt)
-assert('a' == extracted1ch_Cfnfvt)
-assert('b' == extracted2ch_Cfnfvt)
-
-assert(1 == i_Cfnfvt.`a b`)
-assert(2 == i_Cfnfvt.a)
-assert('a' == ch_Cfnfvt.`a b`)
-assert('b' == ch_Cfnfvt.a)
-assert(2 == i_Cfnfvt.p2)
-assert('b' == ch_Cfnfvt.p2)
-
-
-val ch_Cfnfvf = new Cfnfvf('a', 'b')
-val i_Cfnfvf = new Cfnfvf(1, 2)
-val Cfnfvf(extracted1i_Cfnfvf, extracted2i_Cfnfvf) = i_Cfnfvf
-val Cfnfvf(extracted1ch_Cfnfvf, extracted2ch_Cfnfvf) = ch_Cfnfvf
-assert(1 == extracted1i_Cfnfvf)
-assert(2 == extracted2i_Cfnfvf)
-assert('a' == extracted1ch_Cfnfvf)
-assert('b' == extracted2ch_Cfnfvf)
-
-assert(1 == i_Cfnfvf.`a b`)
-assert(2 == i_Cfnfvf.a)
-assert('a' == ch_Cfnfvf.`a b`)
-assert('b' == ch_Cfnfvf.a)
-
-
-val ch_Cfnfnt = new Cfnfnt('a', 'b')
-val i_Cfnfnt = new Cfnfnt(1, 2)
-val Cfnfnt(extracted1i_Cfnfnt, extracted2i_Cfnfnt) = i_Cfnfnt
-val Cfnfnt(extracted1ch_Cfnfnt, extracted2ch_Cfnfnt) = ch_Cfnfnt
-assert(1 == extracted1i_Cfnfnt)
-assert(2 == extracted2i_Cfnfnt)
-assert('a' == extracted1ch_Cfnfnt)
-assert('b' == extracted2ch_Cfnfnt)
-
-assert(1 == i_Cfnfnt.`a b`)
-assert(2 == i_Cfnfnt.a)
-assert('a' == ch_Cfnfnt.`a b`)
-assert('b' == ch_Cfnfnt.a)
-assert(2 == i_Cfnfnt.p2)
-assert('b' == ch_Cfnfnt.p2)
-
-
-val ch_Cfnfnf = new Cfnfnf('a', 'b')
-val i_Cfnfnf = new Cfnfnf(1, 2)
-val Cfnfnf(extracted1i_Cfnfnf, extracted2i_Cfnfnf) = i_Cfnfnf
-val Cfnfnf(extracted1ch_Cfnfnf, extracted2ch_Cfnfnf) = ch_Cfnfnf
-assert(1 == extracted1i_Cfnfnf)
-assert(2 == extracted2i_Cfnfnf)
-assert('a' == extracted1ch_Cfnfnf)
-assert('b' == extracted2ch_Cfnfnf)
-
-assert(1 == i_Cfnfnf.`a b`)
-assert(2 == i_Cfnfnf.a)
-assert('a' == ch_Cfnfnf.`a b`)
-assert('b' == ch_Cfnfnf.a)
-
-
-val ch_Rtpvtpvt = new Rtpvtpvt('a', 'b')
-val i_Rtpvtpvt = new Rtpvtpvt(1, 2)
-assert(1 == i_Rtpvtpvt.p1)
-assert(2 == i_Rtpvtpvt.p2)
-assert('a' == ch_Rtpvtpvt.p1)
-assert('b' == ch_Rtpvtpvt.p2)
-
-
-val ch_Rtpvtpvf = new Rtpvtpvf('a', 'b')
-val i_Rtpvtpvf = new Rtpvtpvf(1, 2)
-assert(1 == i_Rtpvtpvf.p1)
-assert('a' == ch_Rtpvtpvf.p1)
-
-
-val ch_Rtpvtvt = new Rtpvtvt('a', 'b')
-val i_Rtpvtvt = new Rtpvtvt(1, 2)
-assert(2 == i_Rtpvtvt.a)
-assert('b' == ch_Rtpvtvt.a)
-assert(1 == i_Rtpvtvt.p1)
-assert(2 == i_Rtpvtvt.p2)
-assert('a' == ch_Rtpvtvt.p1)
-assert('b' == ch_Rtpvtvt.p2)
-
-
-val ch_Rtpvtvf = new Rtpvtvf('a', 'b')
-val i_Rtpvtvf = new Rtpvtvf(1, 2)
-assert(2 == i_Rtpvtvf.a)
-assert('b' == ch_Rtpvtvf.a)
-assert(1 == i_Rtpvtvf.p1)
-assert('a' == ch_Rtpvtvf.p1)
-
-
-val ch_Rtpvtnt = new Rtpvtnt('a', 'b')
-val i_Rtpvtnt = new Rtpvtnt(1, 2)
-assert(1 == i_Rtpvtnt.p1)
-assert(2 == i_Rtpvtnt.p2)
-assert('a' == ch_Rtpvtnt.p1)
-assert('b' == ch_Rtpvtnt.p2)
-
-
-val ch_Rtpvtnf = new Rtpvtnf('a', 'b')
-val i_Rtpvtnf = new Rtpvtnf(1, 2)
-assert(1 == i_Rtpvtnf.p1)
-assert('a' == ch_Rtpvtnf.p1)
-
-
-val ch_Rtpvfpvt = new Rtpvfpvt('a', 'b')
-val i_Rtpvfpvt = new Rtpvfpvt(1, 2)
-assert(2 == i_Rtpvfpvt.p2)
-assert('b' == ch_Rtpvfpvt.p2)
-
-
-val ch_Rtpvfvt = new Rtpvfvt('a', 'b')
-val i_Rtpvfvt = new Rtpvfvt(1, 2)
-assert(2 == i_Rtpvfvt.a)
-assert('b' == ch_Rtpvfvt.a)
-assert(2 == i_Rtpvfvt.p2)
-assert('b' == ch_Rtpvfvt.p2)
-
-
-val ch_Rtpvfnt = new Rtpvfnt('a', 'b')
-val i_Rtpvfnt = new Rtpvfnt(1, 2)
-assert(2 == i_Rtpvfnt.p2)
-assert('b' == ch_Rtpvfnt.p2)
-
-
-val ch_Rtvtpvt = new Rtvtpvt('a', 'b')
-val i_Rtvtpvt = new Rtvtpvt(1, 2)
-assert(1 == i_Rtvtpvt.`a b`)
-assert('a' == ch_Rtvtpvt.`a b`)
-assert(1 == i_Rtvtpvt.p1)
-assert(2 == i_Rtvtpvt.p2)
-assert('a' == ch_Rtvtpvt.p1)
-assert('b' == ch_Rtvtpvt.p2)
-
-
-val ch_Rtvtpvf = new Rtvtpvf('a', 'b')
-val i_Rtvtpvf = new Rtvtpvf(1, 2)
-assert(1 == i_Rtvtpvf.`a b`)
-assert('a' == ch_Rtvtpvf.`a b`)
-assert(1 == i_Rtvtpvf.p1)
-assert('a' == ch_Rtvtpvf.p1)
-
-
-val ch_Rtvtvt = new Rtvtvt('a', 'b')
-val i_Rtvtvt = new Rtvtvt(1, 2)
-assert(1 == i_Rtvtvt.`a b`)
-assert(2 == i_Rtvtvt.a)
-assert('a' == ch_Rtvtvt.`a b`)
-assert('b' == ch_Rtvtvt.a)
-assert(1 == i_Rtvtvt.p1)
-assert(2 == i_Rtvtvt.p2)
-assert('a' == ch_Rtvtvt.p1)
-assert('b' == ch_Rtvtvt.p2)
-
-
-val ch_Rtvtvf = new Rtvtvf('a', 'b')
-val i_Rtvtvf = new Rtvtvf(1, 2)
-assert(1 == i_Rtvtvf.`a b`)
-assert(2 == i_Rtvtvf.a)
-assert('a' == ch_Rtvtvf.`a b`)
-assert('b' == ch_Rtvtvf.a)
-assert(1 == i_Rtvtvf.p1)
-assert('a' == ch_Rtvtvf.p1)
-
-
-val ch_Rtvtnt = new Rtvtnt('a', 'b')
-val i_Rtvtnt = new Rtvtnt(1, 2)
-assert(1 == i_Rtvtnt.`a b`)
-assert('a' == ch_Rtvtnt.`a b`)
-assert(1 == i_Rtvtnt.p1)
-assert(2 == i_Rtvtnt.p2)
-assert('a' == ch_Rtvtnt.p1)
-assert('b' == ch_Rtvtnt.p2)
-
-
-val ch_Rtvtnf = new Rtvtnf('a', 'b')
-val i_Rtvtnf = new Rtvtnf(1, 2)
-assert(1 == i_Rtvtnf.`a b`)
-assert('a' == ch_Rtvtnf.`a b`)
-assert(1 == i_Rtvtnf.p1)
-assert('a' == ch_Rtvtnf.p1)
-
-
-val ch_Rtvfpvt = new Rtvfpvt('a', 'b')
-val i_Rtvfpvt = new Rtvfpvt(1, 2)
-assert(1 == i_Rtvfpvt.`a b`)
-assert('a' == ch_Rtvfpvt.`a b`)
-assert(2 == i_Rtvfpvt.p2)
-assert('b' == ch_Rtvfpvt.p2)
-
-
-val ch_Rtvfvt = new Rtvfvt('a', 'b')
-val i_Rtvfvt = new Rtvfvt(1, 2)
-assert(1 == i_Rtvfvt.`a b`)
-assert(2 == i_Rtvfvt.a)
-assert('a' == ch_Rtvfvt.`a b`)
-assert('b' == ch_Rtvfvt.a)
-assert(2 == i_Rtvfvt.p2)
-assert('b' == ch_Rtvfvt.p2)
-
-
-val ch_Rtvfnt = new Rtvfnt('a', 'b')
-val i_Rtvfnt = new Rtvfnt(1, 2)
-assert(1 == i_Rtvfnt.`a b`)
-assert('a' == ch_Rtvfnt.`a b`)
-assert(2 == i_Rtvfnt.p2)
-assert('b' == ch_Rtvfnt.p2)
-
-
-val ch_Rtntpvt = new Rtntpvt('a', 'b')
-val i_Rtntpvt = new Rtntpvt(1, 2)
-assert(1 == i_Rtntpvt.p1)
-assert(2 == i_Rtntpvt.p2)
-assert('a' == ch_Rtntpvt.p1)
-assert('b' == ch_Rtntpvt.p2)
-
-
-val ch_Rtntpvf = new Rtntpvf('a', 'b')
-val i_Rtntpvf = new Rtntpvf(1, 2)
-assert(1 == i_Rtntpvf.p1)
-assert('a' == ch_Rtntpvf.p1)
-
-
-val ch_Rtntvt = new Rtntvt('a', 'b')
-val i_Rtntvt = new Rtntvt(1, 2)
-assert(2 == i_Rtntvt.a)
-assert('b' == ch_Rtntvt.a)
-assert(1 == i_Rtntvt.p1)
-assert(2 == i_Rtntvt.p2)
-assert('a' == ch_Rtntvt.p1)
-assert('b' == ch_Rtntvt.p2)
-
-
-val ch_Rtntvf = new Rtntvf('a', 'b')
-val i_Rtntvf = new Rtntvf(1, 2)
-assert(2 == i_Rtntvf.a)
-assert('b' == ch_Rtntvf.a)
-assert(1 == i_Rtntvf.p1)
-assert('a' == ch_Rtntvf.p1)
-
-
-val ch_Rtntnt = new Rtntnt('a', 'b')
-val i_Rtntnt = new Rtntnt(1, 2)
-assert(1 == i_Rtntnt.p1)
-assert(2 == i_Rtntnt.p2)
-assert('a' == ch_Rtntnt.p1)
-assert('b' == ch_Rtntnt.p2)
-
-
-val ch_Rtntnf = new Rtntnf('a', 'b')
-val i_Rtntnf = new Rtntnf(1, 2)
-assert(1 == i_Rtntnf.p1)
-assert('a' == ch_Rtntnf.p1)
-
-
-val ch_Rtnfpvt = new Rtnfpvt('a', 'b')
-val i_Rtnfpvt = new Rtnfpvt(1, 2)
-assert(2 == i_Rtnfpvt.p2)
-assert('b' == ch_Rtnfpvt.p2)
-
-
-val ch_Rtnfvt = new Rtnfvt('a', 'b')
-val i_Rtnfvt = new Rtnfvt(1, 2)
-assert(2 == i_Rtnfvt.a)
-assert('b' == ch_Rtnfvt.a)
-assert(2 == i_Rtnfvt.p2)
-assert('b' == ch_Rtnfvt.p2)
-
-
-val ch_Rtnfnt = new Rtnfnt('a', 'b')
-val i_Rtnfnt = new Rtnfnt(1, 2)
-assert(2 == i_Rtnfnt.p2)
-assert('b' == ch_Rtnfnt.p2)
-
-
-val ch_Rfpvtpvt = new Rfpvtpvt('a', 'b')
-val i_Rfpvtpvt = new Rfpvtpvt(1, 2)
-assert(1 == i_Rfpvtpvt.p1)
-assert(2 == i_Rfpvtpvt.p2)
-assert('a' == ch_Rfpvtpvt.p1)
-assert('b' == ch_Rfpvtpvt.p2)
-
-
-val ch_Rfpvtpvf = new Rfpvtpvf('a', 'b')
-val i_Rfpvtpvf = new Rfpvtpvf(1, 2)
-assert(1 == i_Rfpvtpvf.p1)
-assert('a' == ch_Rfpvtpvf.p1)
-
-
-val ch_Rfpvtvt = new Rfpvtvt('a', 'b')
-val i_Rfpvtvt = new Rfpvtvt(1, 2)
-assert(2 == i_Rfpvtvt.a)
-assert('b' == ch_Rfpvtvt.a)
-assert(1 == i_Rfpvtvt.p1)
-assert(2 == i_Rfpvtvt.p2)
-assert('a' == ch_Rfpvtvt.p1)
-assert('b' == ch_Rfpvtvt.p2)
-
-
-val ch_Rfpvtvf = new Rfpvtvf('a', 'b')
-val i_Rfpvtvf = new Rfpvtvf(1, 2)
-assert(2 == i_Rfpvtvf.a)
-assert('b' == ch_Rfpvtvf.a)
-assert(1 == i_Rfpvtvf.p1)
-assert('a' == ch_Rfpvtvf.p1)
-
-
-val ch_Rfpvtnt = new Rfpvtnt('a', 'b')
-val i_Rfpvtnt = new Rfpvtnt(1, 2)
-assert(1 == i_Rfpvtnt.p1)
-assert(2 == i_Rfpvtnt.p2)
-assert('a' == ch_Rfpvtnt.p1)
-assert('b' == ch_Rfpvtnt.p2)
-
-
-val ch_Rfpvtnf = new Rfpvtnf('a', 'b')
-val i_Rfpvtnf = new Rfpvtnf(1, 2)
-assert(1 == i_Rfpvtnf.p1)
-assert('a' == ch_Rfpvtnf.p1)
-
-
-val ch_Rfpvfpvt = new Rfpvfpvt('a', 'b')
-val i_Rfpvfpvt = new Rfpvfpvt(1, 2)
-assert(2 == i_Rfpvfpvt.p2)
-assert('b' == ch_Rfpvfpvt.p2)
-
-
-val ch_Rfpvfpvf = new Rfpvfpvf('a', 'b')
-val i_Rfpvfpvf = new Rfpvfpvf(1, 2)
-
+val ch_Cpvt_pvt = new Cpvt_pvt('a', 'b')
+val i_Cpvt_pvt = new Cpvt_pvt(1, 2)
+val Cpvt_pvt(extracted1i_Cpvt_pvt, extracted2i_Cpvt_pvt) = i_Cpvt_pvt
+val Cpvt_pvt(extracted1ch_Cpvt_pvt, extracted2ch_Cpvt_pvt) = ch_Cpvt_pvt
+assert(1 == extracted1i_Cpvt_pvt)
+assert(2 == extracted2i_Cpvt_pvt)
+assert('a' == extracted1ch_Cpvt_pvt)
+assert('b' == extracted2ch_Cpvt_pvt)
+
+assert(1 == i_Cpvt_pvt.p1)
+assert(2 == i_Cpvt_pvt.p2)
+assert('a' == ch_Cpvt_pvt.p1)
+assert('b' == ch_Cpvt_pvt.p2)
+
+
+val ch_Cpvt_pvf = new Cpvt_pvf('a', 'b')
+val i_Cpvt_pvf = new Cpvt_pvf(1, 2)
+val Cpvt_pvf(extracted1i_Cpvt_pvf, extracted2i_Cpvt_pvf) = i_Cpvt_pvf
+val Cpvt_pvf(extracted1ch_Cpvt_pvf, extracted2ch_Cpvt_pvf) = ch_Cpvt_pvf
+assert(1 == extracted1i_Cpvt_pvf)
+assert(2 == extracted2i_Cpvt_pvf)
+assert('a' == extracted1ch_Cpvt_pvf)
+assert('b' == extracted2ch_Cpvt_pvf)
+
+assert(1 == i_Cpvt_pvf.p1)
+assert('a' == ch_Cpvt_pvf.p1)
+
+
+val ch_Cpvt_vt = new Cpvt_vt('a', 'b')
+val i_Cpvt_vt = new Cpvt_vt(1, 2)
+val Cpvt_vt(extracted1i_Cpvt_vt, extracted2i_Cpvt_vt) = i_Cpvt_vt
+val Cpvt_vt(extracted1ch_Cpvt_vt, extracted2ch_Cpvt_vt) = ch_Cpvt_vt
+assert(1 == extracted1i_Cpvt_vt)
+assert(2 == extracted2i_Cpvt_vt)
+assert('a' == extracted1ch_Cpvt_vt)
+assert('b' == extracted2ch_Cpvt_vt)
+
+assert(2 == i_Cpvt_vt.a)
+assert('b' == ch_Cpvt_vt.a)
+assert(1 == i_Cpvt_vt.p1)
+assert(2 == i_Cpvt_vt.p2)
+assert('a' == ch_Cpvt_vt.p1)
+assert('b' == ch_Cpvt_vt.p2)
+
+
+val ch_Cpvt_vf = new Cpvt_vf('a', 'b')
+val i_Cpvt_vf = new Cpvt_vf(1, 2)
+val Cpvt_vf(extracted1i_Cpvt_vf, extracted2i_Cpvt_vf) = i_Cpvt_vf
+val Cpvt_vf(extracted1ch_Cpvt_vf, extracted2ch_Cpvt_vf) = ch_Cpvt_vf
+assert(1 == extracted1i_Cpvt_vf)
+assert(2 == extracted2i_Cpvt_vf)
+assert('a' == extracted1ch_Cpvt_vf)
+assert('b' == extracted2ch_Cpvt_vf)
+
+assert(2 == i_Cpvt_vf.a)
+assert('b' == ch_Cpvt_vf.a)
+assert(1 == i_Cpvt_vf.p1)
+assert('a' == ch_Cpvt_vf.p1)
+
+
+val ch_Cpvt_nt = new Cpvt_nt('a', 'b')
+val i_Cpvt_nt = new Cpvt_nt(1, 2)
+val Cpvt_nt(extracted1i_Cpvt_nt, extracted2i_Cpvt_nt) = i_Cpvt_nt
+val Cpvt_nt(extracted1ch_Cpvt_nt, extracted2ch_Cpvt_nt) = ch_Cpvt_nt
+assert(1 == extracted1i_Cpvt_nt)
+assert(2 == extracted2i_Cpvt_nt)
+assert('a' == extracted1ch_Cpvt_nt)
+assert('b' == extracted2ch_Cpvt_nt)
+
+assert(2 == i_Cpvt_nt.a)
+assert('b' == ch_Cpvt_nt.a)
+assert(1 == i_Cpvt_nt.p1)
+assert(2 == i_Cpvt_nt.p2)
+assert('a' == ch_Cpvt_nt.p1)
+assert('b' == ch_Cpvt_nt.p2)
+
+
+val ch_Cpvt_nf = new Cpvt_nf('a', 'b')
+val i_Cpvt_nf = new Cpvt_nf(1, 2)
+val Cpvt_nf(extracted1i_Cpvt_nf, extracted2i_Cpvt_nf) = i_Cpvt_nf
+val Cpvt_nf(extracted1ch_Cpvt_nf, extracted2ch_Cpvt_nf) = ch_Cpvt_nf
+assert(1 == extracted1i_Cpvt_nf)
+assert(2 == extracted2i_Cpvt_nf)
+assert('a' == extracted1ch_Cpvt_nf)
+assert('b' == extracted2ch_Cpvt_nf)
+
+assert(2 == i_Cpvt_nf.a)
+assert('b' == ch_Cpvt_nf.a)
+assert(1 == i_Cpvt_nf.p1)
+assert('a' == ch_Cpvt_nf.p1)
+
+
+val ch_Cpvf_pvt = new Cpvf_pvt('a', 'b')
+val i_Cpvf_pvt = new Cpvf_pvt(1, 2)
+val Cpvf_pvt(extracted1i_Cpvf_pvt, extracted2i_Cpvf_pvt) = i_Cpvf_pvt
+val Cpvf_pvt(extracted1ch_Cpvf_pvt, extracted2ch_Cpvf_pvt) = ch_Cpvf_pvt
+assert(1 == extracted1i_Cpvf_pvt)
+assert(2 == extracted2i_Cpvf_pvt)
+assert('a' == extracted1ch_Cpvf_pvt)
+assert('b' == extracted2ch_Cpvf_pvt)
+
+assert(2 == i_Cpvf_pvt.p2)
+assert('b' == ch_Cpvf_pvt.p2)
+
+
+val ch_Cpvf_pvf = new Cpvf_pvf('a', 'b')
+val i_Cpvf_pvf = new Cpvf_pvf(1, 2)
+val Cpvf_pvf(extracted1i_Cpvf_pvf, extracted2i_Cpvf_pvf) = i_Cpvf_pvf
+val Cpvf_pvf(extracted1ch_Cpvf_pvf, extracted2ch_Cpvf_pvf) = ch_Cpvf_pvf
+assert(1 == extracted1i_Cpvf_pvf)
+assert(2 == extracted2i_Cpvf_pvf)
+assert('a' == extracted1ch_Cpvf_pvf)
+assert('b' == extracted2ch_Cpvf_pvf)
+
+
+
+val ch_Cpvf_vt = new Cpvf_vt('a', 'b')
+val i_Cpvf_vt = new Cpvf_vt(1, 2)
+val Cpvf_vt(extracted1i_Cpvf_vt, extracted2i_Cpvf_vt) = i_Cpvf_vt
+val Cpvf_vt(extracted1ch_Cpvf_vt, extracted2ch_Cpvf_vt) = ch_Cpvf_vt
+assert(1 == extracted1i_Cpvf_vt)
+assert(2 == extracted2i_Cpvf_vt)
+assert('a' == extracted1ch_Cpvf_vt)
+assert('b' == extracted2ch_Cpvf_vt)
+
+assert(2 == i_Cpvf_vt.a)
+assert('b' == ch_Cpvf_vt.a)
+assert(2 == i_Cpvf_vt.p2)
+assert('b' == ch_Cpvf_vt.p2)
+
+
+val ch_Cpvf_vf = new Cpvf_vf('a', 'b')
+val i_Cpvf_vf = new Cpvf_vf(1, 2)
+val Cpvf_vf(extracted1i_Cpvf_vf, extracted2i_Cpvf_vf) = i_Cpvf_vf
+val Cpvf_vf(extracted1ch_Cpvf_vf, extracted2ch_Cpvf_vf) = ch_Cpvf_vf
+assert(1 == extracted1i_Cpvf_vf)
+assert(2 == extracted2i_Cpvf_vf)
+assert('a' == extracted1ch_Cpvf_vf)
+assert('b' == extracted2ch_Cpvf_vf)
+
+assert(2 == i_Cpvf_vf.a)
+assert('b' == ch_Cpvf_vf.a)
+
+
+val ch_Cpvf_nt = new Cpvf_nt('a', 'b')
+val i_Cpvf_nt = new Cpvf_nt(1, 2)
+val Cpvf_nt(extracted1i_Cpvf_nt, extracted2i_Cpvf_nt) = i_Cpvf_nt
+val Cpvf_nt(extracted1ch_Cpvf_nt, extracted2ch_Cpvf_nt) = ch_Cpvf_nt
+assert(1 == extracted1i_Cpvf_nt)
+assert(2 == extracted2i_Cpvf_nt)
+assert('a' == extracted1ch_Cpvf_nt)
+assert('b' == extracted2ch_Cpvf_nt)
+
+assert(2 == i_Cpvf_nt.a)
+assert('b' == ch_Cpvf_nt.a)
+assert(2 == i_Cpvf_nt.p2)
+assert('b' == ch_Cpvf_nt.p2)
+
+
+val ch_Cpvf_nf = new Cpvf_nf('a', 'b')
+val i_Cpvf_nf = new Cpvf_nf(1, 2)
+val Cpvf_nf(extracted1i_Cpvf_nf, extracted2i_Cpvf_nf) = i_Cpvf_nf
+val Cpvf_nf(extracted1ch_Cpvf_nf, extracted2ch_Cpvf_nf) = ch_Cpvf_nf
+assert(1 == extracted1i_Cpvf_nf)
+assert(2 == extracted2i_Cpvf_nf)
+assert('a' == extracted1ch_Cpvf_nf)
+assert('b' == extracted2ch_Cpvf_nf)
+
+assert(2 == i_Cpvf_nf.a)
+assert('b' == ch_Cpvf_nf.a)
+
+
+val ch_Cvt_pvt = new Cvt_pvt('a', 'b')
+val i_Cvt_pvt = new Cvt_pvt(1, 2)
+val Cvt_pvt(extracted1i_Cvt_pvt, extracted2i_Cvt_pvt) = i_Cvt_pvt
+val Cvt_pvt(extracted1ch_Cvt_pvt, extracted2ch_Cvt_pvt) = ch_Cvt_pvt
+assert(1 == extracted1i_Cvt_pvt)
+assert(2 == extracted2i_Cvt_pvt)
+assert('a' == extracted1ch_Cvt_pvt)
+assert('b' == extracted2ch_Cvt_pvt)
+
+assert(1 == i_Cvt_pvt.`a b`)
+assert('a' == ch_Cvt_pvt.`a b`)
+assert(1 == i_Cvt_pvt.p1)
+assert(2 == i_Cvt_pvt.p2)
+assert('a' == ch_Cvt_pvt.p1)
+assert('b' == ch_Cvt_pvt.p2)
+
+
+val ch_Cvt_pvf = new Cvt_pvf('a', 'b')
+val i_Cvt_pvf = new Cvt_pvf(1, 2)
+val Cvt_pvf(extracted1i_Cvt_pvf, extracted2i_Cvt_pvf) = i_Cvt_pvf
+val Cvt_pvf(extracted1ch_Cvt_pvf, extracted2ch_Cvt_pvf) = ch_Cvt_pvf
+assert(1 == extracted1i_Cvt_pvf)
+assert(2 == extracted2i_Cvt_pvf)
+assert('a' == extracted1ch_Cvt_pvf)
+assert('b' == extracted2ch_Cvt_pvf)
+
+assert(1 == i_Cvt_pvf.`a b`)
+assert('a' == ch_Cvt_pvf.`a b`)
+assert(1 == i_Cvt_pvf.p1)
+assert('a' == ch_Cvt_pvf.p1)
+
+
+val ch_Cvt_vt = new Cvt_vt('a', 'b')
+val i_Cvt_vt = new Cvt_vt(1, 2)
+val Cvt_vt(extracted1i_Cvt_vt, extracted2i_Cvt_vt) = i_Cvt_vt
+val Cvt_vt(extracted1ch_Cvt_vt, extracted2ch_Cvt_vt) = ch_Cvt_vt
+assert(1 == extracted1i_Cvt_vt)
+assert(2 == extracted2i_Cvt_vt)
+assert('a' == extracted1ch_Cvt_vt)
+assert('b' == extracted2ch_Cvt_vt)
+
+assert(1 == i_Cvt_vt.`a b`)
+assert(2 == i_Cvt_vt.a)
+assert('a' == ch_Cvt_vt.`a b`)
+assert('b' == ch_Cvt_vt.a)
+assert(1 == i_Cvt_vt.p1)
+assert(2 == i_Cvt_vt.p2)
+assert('a' == ch_Cvt_vt.p1)
+assert('b' == ch_Cvt_vt.p2)
+
+
+val ch_Cvt_vf = new Cvt_vf('a', 'b')
+val i_Cvt_vf = new Cvt_vf(1, 2)
+val Cvt_vf(extracted1i_Cvt_vf, extracted2i_Cvt_vf) = i_Cvt_vf
+val Cvt_vf(extracted1ch_Cvt_vf, extracted2ch_Cvt_vf) = ch_Cvt_vf
+assert(1 == extracted1i_Cvt_vf)
+assert(2 == extracted2i_Cvt_vf)
+assert('a' == extracted1ch_Cvt_vf)
+assert('b' == extracted2ch_Cvt_vf)
+
+assert(1 == i_Cvt_vf.`a b`)
+assert(2 == i_Cvt_vf.a)
+assert('a' == ch_Cvt_vf.`a b`)
+assert('b' == ch_Cvt_vf.a)
+assert(1 == i_Cvt_vf.p1)
+assert('a' == ch_Cvt_vf.p1)
+
+
+val ch_Cvt_nt = new Cvt_nt('a', 'b')
+val i_Cvt_nt = new Cvt_nt(1, 2)
+val Cvt_nt(extracted1i_Cvt_nt, extracted2i_Cvt_nt) = i_Cvt_nt
+val Cvt_nt(extracted1ch_Cvt_nt, extracted2ch_Cvt_nt) = ch_Cvt_nt
+assert(1 == extracted1i_Cvt_nt)
+assert(2 == extracted2i_Cvt_nt)
+assert('a' == extracted1ch_Cvt_nt)
+assert('b' == extracted2ch_Cvt_nt)
+
+assert(1 == i_Cvt_nt.`a b`)
+assert(2 == i_Cvt_nt.a)
+assert('a' == ch_Cvt_nt.`a b`)
+assert('b' == ch_Cvt_nt.a)
+assert(1 == i_Cvt_nt.p1)
+assert(2 == i_Cvt_nt.p2)
+assert('a' == ch_Cvt_nt.p1)
+assert('b' == ch_Cvt_nt.p2)
+
+
+val ch_Cvt_nf = new Cvt_nf('a', 'b')
+val i_Cvt_nf = new Cvt_nf(1, 2)
+val Cvt_nf(extracted1i_Cvt_nf, extracted2i_Cvt_nf) = i_Cvt_nf
+val Cvt_nf(extracted1ch_Cvt_nf, extracted2ch_Cvt_nf) = ch_Cvt_nf
+assert(1 == extracted1i_Cvt_nf)
+assert(2 == extracted2i_Cvt_nf)
+assert('a' == extracted1ch_Cvt_nf)
+assert('b' == extracted2ch_Cvt_nf)
+
+assert(1 == i_Cvt_nf.`a b`)
+assert(2 == i_Cvt_nf.a)
+assert('a' == ch_Cvt_nf.`a b`)
+assert('b' == ch_Cvt_nf.a)
+assert(1 == i_Cvt_nf.p1)
+assert('a' == ch_Cvt_nf.p1)
+
+
+val ch_Cvf_pvt = new Cvf_pvt('a', 'b')
+val i_Cvf_pvt = new Cvf_pvt(1, 2)
+val Cvf_pvt(extracted1i_Cvf_pvt, extracted2i_Cvf_pvt) = i_Cvf_pvt
+val Cvf_pvt(extracted1ch_Cvf_pvt, extracted2ch_Cvf_pvt) = ch_Cvf_pvt
+assert(1 == extracted1i_Cvf_pvt)
+assert(2 == extracted2i_Cvf_pvt)
+assert('a' == extracted1ch_Cvf_pvt)
+assert('b' == extracted2ch_Cvf_pvt)
+
+assert(1 == i_Cvf_pvt.`a b`)
+assert('a' == ch_Cvf_pvt.`a b`)
+assert(2 == i_Cvf_pvt.p2)
+assert('b' == ch_Cvf_pvt.p2)
+
+
+val ch_Cvf_pvf = new Cvf_pvf('a', 'b')
+val i_Cvf_pvf = new Cvf_pvf(1, 2)
+val Cvf_pvf(extracted1i_Cvf_pvf, extracted2i_Cvf_pvf) = i_Cvf_pvf
+val Cvf_pvf(extracted1ch_Cvf_pvf, extracted2ch_Cvf_pvf) = ch_Cvf_pvf
+assert(1 == extracted1i_Cvf_pvf)
+assert(2 == extracted2i_Cvf_pvf)
+assert('a' == extracted1ch_Cvf_pvf)
+assert('b' == extracted2ch_Cvf_pvf)
+
+assert(1 == i_Cvf_pvf.`a b`)
+assert('a' == ch_Cvf_pvf.`a b`)
+
+
+val ch_Cvf_vt = new Cvf_vt('a', 'b')
+val i_Cvf_vt = new Cvf_vt(1, 2)
+val Cvf_vt(extracted1i_Cvf_vt, extracted2i_Cvf_vt) = i_Cvf_vt
+val Cvf_vt(extracted1ch_Cvf_vt, extracted2ch_Cvf_vt) = ch_Cvf_vt
+assert(1 == extracted1i_Cvf_vt)
+assert(2 == extracted2i_Cvf_vt)
+assert('a' == extracted1ch_Cvf_vt)
+assert('b' == extracted2ch_Cvf_vt)
+
+assert(1 == i_Cvf_vt.`a b`)
+assert(2 == i_Cvf_vt.a)
+assert('a' == ch_Cvf_vt.`a b`)
+assert('b' == ch_Cvf_vt.a)
+assert(2 == i_Cvf_vt.p2)
+assert('b' == ch_Cvf_vt.p2)
+
+
+val ch_Cvf_vf = new Cvf_vf('a', 'b')
+val i_Cvf_vf = new Cvf_vf(1, 2)
+val Cvf_vf(extracted1i_Cvf_vf, extracted2i_Cvf_vf) = i_Cvf_vf
+val Cvf_vf(extracted1ch_Cvf_vf, extracted2ch_Cvf_vf) = ch_Cvf_vf
+assert(1 == extracted1i_Cvf_vf)
+assert(2 == extracted2i_Cvf_vf)
+assert('a' == extracted1ch_Cvf_vf)
+assert('b' == extracted2ch_Cvf_vf)
+
+assert(1 == i_Cvf_vf.`a b`)
+assert(2 == i_Cvf_vf.a)
+assert('a' == ch_Cvf_vf.`a b`)
+assert('b' == ch_Cvf_vf.a)
+
+
+val ch_Cvf_nt = new Cvf_nt('a', 'b')
+val i_Cvf_nt = new Cvf_nt(1, 2)
+val Cvf_nt(extracted1i_Cvf_nt, extracted2i_Cvf_nt) = i_Cvf_nt
+val Cvf_nt(extracted1ch_Cvf_nt, extracted2ch_Cvf_nt) = ch_Cvf_nt
+assert(1 == extracted1i_Cvf_nt)
+assert(2 == extracted2i_Cvf_nt)
+assert('a' == extracted1ch_Cvf_nt)
+assert('b' == extracted2ch_Cvf_nt)
+
+assert(1 == i_Cvf_nt.`a b`)
+assert(2 == i_Cvf_nt.a)
+assert('a' == ch_Cvf_nt.`a b`)
+assert('b' == ch_Cvf_nt.a)
+assert(2 == i_Cvf_nt.p2)
+assert('b' == ch_Cvf_nt.p2)
+
+
+val ch_Cvf_nf = new Cvf_nf('a', 'b')
+val i_Cvf_nf = new Cvf_nf(1, 2)
+val Cvf_nf(extracted1i_Cvf_nf, extracted2i_Cvf_nf) = i_Cvf_nf
+val Cvf_nf(extracted1ch_Cvf_nf, extracted2ch_Cvf_nf) = ch_Cvf_nf
+assert(1 == extracted1i_Cvf_nf)
+assert(2 == extracted2i_Cvf_nf)
+assert('a' == extracted1ch_Cvf_nf)
+assert('b' == extracted2ch_Cvf_nf)
+
+assert(1 == i_Cvf_nf.`a b`)
+assert(2 == i_Cvf_nf.a)
+assert('a' == ch_Cvf_nf.`a b`)
+assert('b' == ch_Cvf_nf.a)
+
+
+val ch_Cnt_pvt = new Cnt_pvt('a', 'b')
+val i_Cnt_pvt = new Cnt_pvt(1, 2)
+val Cnt_pvt(extracted1i_Cnt_pvt, extracted2i_Cnt_pvt) = i_Cnt_pvt
+val Cnt_pvt(extracted1ch_Cnt_pvt, extracted2ch_Cnt_pvt) = ch_Cnt_pvt
+assert(1 == extracted1i_Cnt_pvt)
+assert(2 == extracted2i_Cnt_pvt)
+assert('a' == extracted1ch_Cnt_pvt)
+assert('b' == extracted2ch_Cnt_pvt)
+
+assert(1 == i_Cnt_pvt.`a b`)
+assert('a' == ch_Cnt_pvt.`a b`)
+assert(1 == i_Cnt_pvt.p1)
+assert(2 == i_Cnt_pvt.p2)
+assert('a' == ch_Cnt_pvt.p1)
+assert('b' == ch_Cnt_pvt.p2)
+
+
+val ch_Cnt_pvf = new Cnt_pvf('a', 'b')
+val i_Cnt_pvf = new Cnt_pvf(1, 2)
+val Cnt_pvf(extracted1i_Cnt_pvf, extracted2i_Cnt_pvf) = i_Cnt_pvf
+val Cnt_pvf(extracted1ch_Cnt_pvf, extracted2ch_Cnt_pvf) = ch_Cnt_pvf
+assert(1 == extracted1i_Cnt_pvf)
+assert(2 == extracted2i_Cnt_pvf)
+assert('a' == extracted1ch_Cnt_pvf)
+assert('b' == extracted2ch_Cnt_pvf)
+
+assert(1 == i_Cnt_pvf.`a b`)
+assert('a' == ch_Cnt_pvf.`a b`)
+assert(1 == i_Cnt_pvf.p1)
+assert('a' == ch_Cnt_pvf.p1)
+
+
+val ch_Cnt_vt = new Cnt_vt('a', 'b')
+val i_Cnt_vt = new Cnt_vt(1, 2)
+val Cnt_vt(extracted1i_Cnt_vt, extracted2i_Cnt_vt) = i_Cnt_vt
+val Cnt_vt(extracted1ch_Cnt_vt, extracted2ch_Cnt_vt) = ch_Cnt_vt
+assert(1 == extracted1i_Cnt_vt)
+assert(2 == extracted2i_Cnt_vt)
+assert('a' == extracted1ch_Cnt_vt)
+assert('b' == extracted2ch_Cnt_vt)
+
+assert(1 == i_Cnt_vt.`a b`)
+assert(2 == i_Cnt_vt.a)
+assert('a' == ch_Cnt_vt.`a b`)
+assert('b' == ch_Cnt_vt.a)
+assert(1 == i_Cnt_vt.p1)
+assert(2 == i_Cnt_vt.p2)
+assert('a' == ch_Cnt_vt.p1)
+assert('b' == ch_Cnt_vt.p2)
+
+
+val ch_Cnt_vf = new Cnt_vf('a', 'b')
+val i_Cnt_vf = new Cnt_vf(1, 2)
+val Cnt_vf(extracted1i_Cnt_vf, extracted2i_Cnt_vf) = i_Cnt_vf
+val Cnt_vf(extracted1ch_Cnt_vf, extracted2ch_Cnt_vf) = ch_Cnt_vf
+assert(1 == extracted1i_Cnt_vf)
+assert(2 == extracted2i_Cnt_vf)
+assert('a' == extracted1ch_Cnt_vf)
+assert('b' == extracted2ch_Cnt_vf)
+
+assert(1 == i_Cnt_vf.`a b`)
+assert(2 == i_Cnt_vf.a)
+assert('a' == ch_Cnt_vf.`a b`)
+assert('b' == ch_Cnt_vf.a)
+assert(1 == i_Cnt_vf.p1)
+assert('a' == ch_Cnt_vf.p1)
+
+
+val ch_Cnt_nt = new Cnt_nt('a', 'b')
+val i_Cnt_nt = new Cnt_nt(1, 2)
+val Cnt_nt(extracted1i_Cnt_nt, extracted2i_Cnt_nt) = i_Cnt_nt
+val Cnt_nt(extracted1ch_Cnt_nt, extracted2ch_Cnt_nt) = ch_Cnt_nt
+assert(1 == extracted1i_Cnt_nt)
+assert(2 == extracted2i_Cnt_nt)
+assert('a' == extracted1ch_Cnt_nt)
+assert('b' == extracted2ch_Cnt_nt)
+
+assert(1 == i_Cnt_nt.`a b`)
+assert(2 == i_Cnt_nt.a)
+assert('a' == ch_Cnt_nt.`a b`)
+assert('b' == ch_Cnt_nt.a)
+assert(1 == i_Cnt_nt.p1)
+assert(2 == i_Cnt_nt.p2)
+assert('a' == ch_Cnt_nt.p1)
+assert('b' == ch_Cnt_nt.p2)
+
+
+val ch_Cnt_nf = new Cnt_nf('a', 'b')
+val i_Cnt_nf = new Cnt_nf(1, 2)
+val Cnt_nf(extracted1i_Cnt_nf, extracted2i_Cnt_nf) = i_Cnt_nf
+val Cnt_nf(extracted1ch_Cnt_nf, extracted2ch_Cnt_nf) = ch_Cnt_nf
+assert(1 == extracted1i_Cnt_nf)
+assert(2 == extracted2i_Cnt_nf)
+assert('a' == extracted1ch_Cnt_nf)
+assert('b' == extracted2ch_Cnt_nf)
+
+assert(1 == i_Cnt_nf.`a b`)
+assert(2 == i_Cnt_nf.a)
+assert('a' == ch_Cnt_nf.`a b`)
+assert('b' == ch_Cnt_nf.a)
+assert(1 == i_Cnt_nf.p1)
+assert('a' == ch_Cnt_nf.p1)
+
+
+val ch_Cnf_pvt = new Cnf_pvt('a', 'b')
+val i_Cnf_pvt = new Cnf_pvt(1, 2)
+val Cnf_pvt(extracted1i_Cnf_pvt, extracted2i_Cnf_pvt) = i_Cnf_pvt
+val Cnf_pvt(extracted1ch_Cnf_pvt, extracted2ch_Cnf_pvt) = ch_Cnf_pvt
+assert(1 == extracted1i_Cnf_pvt)
+assert(2 == extracted2i_Cnf_pvt)
+assert('a' == extracted1ch_Cnf_pvt)
+assert('b' == extracted2ch_Cnf_pvt)
+
+assert(1 == i_Cnf_pvt.`a b`)
+assert('a' == ch_Cnf_pvt.`a b`)
+assert(2 == i_Cnf_pvt.p2)
+assert('b' == ch_Cnf_pvt.p2)
+
+
+val ch_Cnf_pvf = new Cnf_pvf('a', 'b')
+val i_Cnf_pvf = new Cnf_pvf(1, 2)
+val Cnf_pvf(extracted1i_Cnf_pvf, extracted2i_Cnf_pvf) = i_Cnf_pvf
+val Cnf_pvf(extracted1ch_Cnf_pvf, extracted2ch_Cnf_pvf) = ch_Cnf_pvf
+assert(1 == extracted1i_Cnf_pvf)
+assert(2 == extracted2i_Cnf_pvf)
+assert('a' == extracted1ch_Cnf_pvf)
+assert('b' == extracted2ch_Cnf_pvf)
+
+assert(1 == i_Cnf_pvf.`a b`)
+assert('a' == ch_Cnf_pvf.`a b`)
+
+
+val ch_Cnf_vt = new Cnf_vt('a', 'b')
+val i_Cnf_vt = new Cnf_vt(1, 2)
+val Cnf_vt(extracted1i_Cnf_vt, extracted2i_Cnf_vt) = i_Cnf_vt
+val Cnf_vt(extracted1ch_Cnf_vt, extracted2ch_Cnf_vt) = ch_Cnf_vt
+assert(1 == extracted1i_Cnf_vt)
+assert(2 == extracted2i_Cnf_vt)
+assert('a' == extracted1ch_Cnf_vt)
+assert('b' == extracted2ch_Cnf_vt)
+
+assert(1 == i_Cnf_vt.`a b`)
+assert(2 == i_Cnf_vt.a)
+assert('a' == ch_Cnf_vt.`a b`)
+assert('b' == ch_Cnf_vt.a)
+assert(2 == i_Cnf_vt.p2)
+assert('b' == ch_Cnf_vt.p2)
+
+
+val ch_Cnf_vf = new Cnf_vf('a', 'b')
+val i_Cnf_vf = new Cnf_vf(1, 2)
+val Cnf_vf(extracted1i_Cnf_vf, extracted2i_Cnf_vf) = i_Cnf_vf
+val Cnf_vf(extracted1ch_Cnf_vf, extracted2ch_Cnf_vf) = ch_Cnf_vf
+assert(1 == extracted1i_Cnf_vf)
+assert(2 == extracted2i_Cnf_vf)
+assert('a' == extracted1ch_Cnf_vf)
+assert('b' == extracted2ch_Cnf_vf)
+
+assert(1 == i_Cnf_vf.`a b`)
+assert(2 == i_Cnf_vf.a)
+assert('a' == ch_Cnf_vf.`a b`)
+assert('b' == ch_Cnf_vf.a)
+
+
+val ch_Cnf_nt = new Cnf_nt('a', 'b')
+val i_Cnf_nt = new Cnf_nt(1, 2)
+val Cnf_nt(extracted1i_Cnf_nt, extracted2i_Cnf_nt) = i_Cnf_nt
+val Cnf_nt(extracted1ch_Cnf_nt, extracted2ch_Cnf_nt) = ch_Cnf_nt
+assert(1 == extracted1i_Cnf_nt)
+assert(2 == extracted2i_Cnf_nt)
+assert('a' == extracted1ch_Cnf_nt)
+assert('b' == extracted2ch_Cnf_nt)
+
+assert(1 == i_Cnf_nt.`a b`)
+assert(2 == i_Cnf_nt.a)
+assert('a' == ch_Cnf_nt.`a b`)
+assert('b' == ch_Cnf_nt.a)
+assert(2 == i_Cnf_nt.p2)
+assert('b' == ch_Cnf_nt.p2)
+
+
+val ch_Cnf_nf = new Cnf_nf('a', 'b')
+val i_Cnf_nf = new Cnf_nf(1, 2)
+val Cnf_nf(extracted1i_Cnf_nf, extracted2i_Cnf_nf) = i_Cnf_nf
+val Cnf_nf(extracted1ch_Cnf_nf, extracted2ch_Cnf_nf) = ch_Cnf_nf
+assert(1 == extracted1i_Cnf_nf)
+assert(2 == extracted2i_Cnf_nf)
+assert('a' == extracted1ch_Cnf_nf)
+assert('b' == extracted2ch_Cnf_nf)
+
+assert(1 == i_Cnf_nf.`a b`)
+assert(2 == i_Cnf_nf.a)
+assert('a' == ch_Cnf_nf.`a b`)
+assert('b' == ch_Cnf_nf.a)
+
+
+val ch_Rpvt_pvt = new Rpvt_pvt('a', 'b')
+val i_Rpvt_pvt = new Rpvt_pvt(1, 2)
+assert(1 == i_Rpvt_pvt.p1)
+assert(2 == i_Rpvt_pvt.p2)
+assert('a' == ch_Rpvt_pvt.p1)
+assert('b' == ch_Rpvt_pvt.p2)
+
+
+val ch_Rpvt_pvf = new Rpvt_pvf('a', 'b')
+val i_Rpvt_pvf = new Rpvt_pvf(1, 2)
+assert(1 == i_Rpvt_pvf.p1)
+assert('a' == ch_Rpvt_pvf.p1)
+
+
+val ch_Rpvt_vt = new Rpvt_vt('a', 'b')
+val i_Rpvt_vt = new Rpvt_vt(1, 2)
+assert(2 == i_Rpvt_vt.a)
+assert('b' == ch_Rpvt_vt.a)
+assert(1 == i_Rpvt_vt.p1)
+assert(2 == i_Rpvt_vt.p2)
+assert('a' == ch_Rpvt_vt.p1)
+assert('b' == ch_Rpvt_vt.p2)
+
+
+val ch_Rpvt_vf = new Rpvt_vf('a', 'b')
+val i_Rpvt_vf = new Rpvt_vf(1, 2)
+assert(2 == i_Rpvt_vf.a)
+assert('b' == ch_Rpvt_vf.a)
+assert(1 == i_Rpvt_vf.p1)
+assert('a' == ch_Rpvt_vf.p1)
+
+
+val ch_Rpvt_nt = new Rpvt_nt('a', 'b')
+val i_Rpvt_nt = new Rpvt_nt(1, 2)
+assert(1 == i_Rpvt_nt.p1)
+assert(2 == i_Rpvt_nt.p2)
+assert('a' == ch_Rpvt_nt.p1)
+assert('b' == ch_Rpvt_nt.p2)
+
+
+val ch_Rpvt_nf = new Rpvt_nf('a', 'b')
+val i_Rpvt_nf = new Rpvt_nf(1, 2)
+assert(1 == i_Rpvt_nf.p1)
+assert('a' == ch_Rpvt_nf.p1)
+
+
+val ch_Rpvf_pvt = new Rpvf_pvt('a', 'b')
+val i_Rpvf_pvt = new Rpvf_pvt(1, 2)
+assert(2 == i_Rpvf_pvt.p2)
+assert('b' == ch_Rpvf_pvt.p2)
 
-val ch_Rfpvfvt = new Rfpvfvt('a', 'b')
-val i_Rfpvfvt = new Rfpvfvt(1, 2)
-assert(2 == i_Rfpvfvt.a)
-assert('b' == ch_Rfpvfvt.a)
-assert(2 == i_Rfpvfvt.p2)
-assert('b' == ch_Rfpvfvt.p2)
 
+val ch_Rpvf_pvf = new Rpvf_pvf('a', 'b')
+val i_Rpvf_pvf = new Rpvf_pvf(1, 2)
+
+
+val ch_Rpvf_vt = new Rpvf_vt('a', 'b')
+val i_Rpvf_vt = new Rpvf_vt(1, 2)
+assert(2 == i_Rpvf_vt.a)
+assert('b' == ch_Rpvf_vt.a)
+assert(2 == i_Rpvf_vt.p2)
+assert('b' == ch_Rpvf_vt.p2)
 
-val ch_Rfpvfvf = new Rfpvfvf('a', 'b')
-val i_Rfpvfvf = new Rfpvfvf(1, 2)
-assert(2 == i_Rfpvfvf.a)
-assert('b' == ch_Rfpvfvf.a)
+
+val ch_Rpvf_vf = new Rpvf_vf('a', 'b')
+val i_Rpvf_vf = new Rpvf_vf(1, 2)
+assert(2 == i_Rpvf_vf.a)
+assert('b' == ch_Rpvf_vf.a)
 
 
-val ch_Rfpvfnt = new Rfpvfnt('a', 'b')
-val i_Rfpvfnt = new Rfpvfnt(1, 2)
-assert(2 == i_Rfpvfnt.p2)
-assert('b' == ch_Rfpvfnt.p2)
+val ch_Rpvf_nt = new Rpvf_nt('a', 'b')
+val i_Rpvf_nt = new Rpvf_nt(1, 2)
+assert(2 == i_Rpvf_nt.p2)
+assert('b' == ch_Rpvf_nt.p2)
 
 
-val ch_Rfpvfnf = new Rfpvfnf('a', 'b')
-val i_Rfpvfnf = new Rfpvfnf(1, 2)
+val ch_Rpvf_nf = new Rpvf_nf('a', 'b')
+val i_Rpvf_nf = new Rpvf_nf(1, 2)
 
 
-val ch_Rfvtpvt = new Rfvtpvt('a', 'b')
-val i_Rfvtpvt = new Rfvtpvt(1, 2)
-assert(1 == i_Rfvtpvt.`a b`)
-assert('a' == ch_Rfvtpvt.`a b`)
-assert(1 == i_Rfvtpvt.p1)
-assert(2 == i_Rfvtpvt.p2)
-assert('a' == ch_Rfvtpvt.p1)
-assert('b' == ch_Rfvtpvt.p2)
+val ch_Rvt_pvt = new Rvt_pvt('a', 'b')
+val i_Rvt_pvt = new Rvt_pvt(1, 2)
+assert(1 == i_Rvt_pvt.`a b`)
+assert('a' == ch_Rvt_pvt.`a b`)
+assert(1 == i_Rvt_pvt.p1)
+assert(2 == i_Rvt_pvt.p2)
+assert('a' == ch_Rvt_pvt.p1)
+assert('b' == ch_Rvt_pvt.p2)
 
 
-val ch_Rfvtpvf = new Rfvtpvf('a', 'b')
-val i_Rfvtpvf = new Rfvtpvf(1, 2)
-assert(1 == i_Rfvtpvf.`a b`)
-assert('a' == ch_Rfvtpvf.`a b`)
-assert(1 == i_Rfvtpvf.p1)
-assert('a' == ch_Rfvtpvf.p1)
+val ch_Rvt_pvf = new Rvt_pvf('a', 'b')
+val i_Rvt_pvf = new Rvt_pvf(1, 2)
+assert(1 == i_Rvt_pvf.`a b`)
+assert('a' == ch_Rvt_pvf.`a b`)
+assert(1 == i_Rvt_pvf.p1)
+assert('a' == ch_Rvt_pvf.p1)
 
 
-val ch_Rfvtvt = new Rfvtvt('a', 'b')
-val i_Rfvtvt = new Rfvtvt(1, 2)
-assert(1 == i_Rfvtvt.`a b`)
-assert(2 == i_Rfvtvt.a)
-assert('a' == ch_Rfvtvt.`a b`)
-assert('b' == ch_Rfvtvt.a)
-assert(1 == i_Rfvtvt.p1)
-assert(2 == i_Rfvtvt.p2)
-assert('a' == ch_Rfvtvt.p1)
-assert('b' == ch_Rfvtvt.p2)
+val ch_Rvt_vt = new Rvt_vt('a', 'b')
+val i_Rvt_vt = new Rvt_vt(1, 2)
+assert(1 == i_Rvt_vt.`a b`)
+assert(2 == i_Rvt_vt.a)
+assert('a' == ch_Rvt_vt.`a b`)
+assert('b' == ch_Rvt_vt.a)
+assert(1 == i_Rvt_vt.p1)
+assert(2 == i_Rvt_vt.p2)
+assert('a' == ch_Rvt_vt.p1)
+assert('b' == ch_Rvt_vt.p2)
 
 
-val ch_Rfvtvf = new Rfvtvf('a', 'b')
-val i_Rfvtvf = new Rfvtvf(1, 2)
-assert(1 == i_Rfvtvf.`a b`)
-assert(2 == i_Rfvtvf.a)
-assert('a' == ch_Rfvtvf.`a b`)
-assert('b' == ch_Rfvtvf.a)
-assert(1 == i_Rfvtvf.p1)
-assert('a' == ch_Rfvtvf.p1)
+val ch_Rvt_vf = new Rvt_vf('a', 'b')
+val i_Rvt_vf = new Rvt_vf(1, 2)
+assert(1 == i_Rvt_vf.`a b`)
+assert(2 == i_Rvt_vf.a)
+assert('a' == ch_Rvt_vf.`a b`)
+assert('b' == ch_Rvt_vf.a)
+assert(1 == i_Rvt_vf.p1)
+assert('a' == ch_Rvt_vf.p1)
 
 
-val ch_Rfvtnt = new Rfvtnt('a', 'b')
-val i_Rfvtnt = new Rfvtnt(1, 2)
-assert(1 == i_Rfvtnt.`a b`)
-assert('a' == ch_Rfvtnt.`a b`)
-assert(1 == i_Rfvtnt.p1)
-assert(2 == i_Rfvtnt.p2)
-assert('a' == ch_Rfvtnt.p1)
-assert('b' == ch_Rfvtnt.p2)
+val ch_Rvt_nt = new Rvt_nt('a', 'b')
+val i_Rvt_nt = new Rvt_nt(1, 2)
+assert(1 == i_Rvt_nt.`a b`)
+assert('a' == ch_Rvt_nt.`a b`)
+assert(1 == i_Rvt_nt.p1)
+assert(2 == i_Rvt_nt.p2)
+assert('a' == ch_Rvt_nt.p1)
+assert('b' == ch_Rvt_nt.p2)
 
 
-val ch_Rfvtnf = new Rfvtnf('a', 'b')
-val i_Rfvtnf = new Rfvtnf(1, 2)
-assert(1 == i_Rfvtnf.`a b`)
-assert('a' == ch_Rfvtnf.`a b`)
-assert(1 == i_Rfvtnf.p1)
-assert('a' == ch_Rfvtnf.p1)
+val ch_Rvt_nf = new Rvt_nf('a', 'b')
+val i_Rvt_nf = new Rvt_nf(1, 2)
+assert(1 == i_Rvt_nf.`a b`)
+assert('a' == ch_Rvt_nf.`a b`)
+assert(1 == i_Rvt_nf.p1)
+assert('a' == ch_Rvt_nf.p1)
 
 
-val ch_Rfvfpvt = new Rfvfpvt('a', 'b')
-val i_Rfvfpvt = new Rfvfpvt(1, 2)
-assert(1 == i_Rfvfpvt.`a b`)
-assert('a' == ch_Rfvfpvt.`a b`)
-assert(2 == i_Rfvfpvt.p2)
-assert('b' == ch_Rfvfpvt.p2)
+val ch_Rvf_pvt = new Rvf_pvt('a', 'b')
+val i_Rvf_pvt = new Rvf_pvt(1, 2)
+assert(1 == i_Rvf_pvt.`a b`)
+assert('a' == ch_Rvf_pvt.`a b`)
+assert(2 == i_Rvf_pvt.p2)
+assert('b' == ch_Rvf_pvt.p2)
 
 
-val ch_Rfvfpvf = new Rfvfpvf('a', 'b')
-val i_Rfvfpvf = new Rfvfpvf(1, 2)
-assert(1 == i_Rfvfpvf.`a b`)
-assert('a' == ch_Rfvfpvf.`a b`)
+val ch_Rvf_pvf = new Rvf_pvf('a', 'b')
+val i_Rvf_pvf = new Rvf_pvf(1, 2)
+assert(1 == i_Rvf_pvf.`a b`)
+assert('a' == ch_Rvf_pvf.`a b`)
 
 
-val ch_Rfvfvt = new Rfvfvt('a', 'b')
-val i_Rfvfvt = new Rfvfvt(1, 2)
-assert(1 == i_Rfvfvt.`a b`)
-assert(2 == i_Rfvfvt.a)
-assert('a' == ch_Rfvfvt.`a b`)
-assert('b' == ch_Rfvfvt.a)
-assert(2 == i_Rfvfvt.p2)
-assert('b' == ch_Rfvfvt.p2)
+val ch_Rvf_vt = new Rvf_vt('a', 'b')
+val i_Rvf_vt = new Rvf_vt(1, 2)
+assert(1 == i_Rvf_vt.`a b`)
+assert(2 == i_Rvf_vt.a)
+assert('a' == ch_Rvf_vt.`a b`)
+assert('b' == ch_Rvf_vt.a)
+assert(2 == i_Rvf_vt.p2)
+assert('b' == ch_Rvf_vt.p2)
 
 
-val ch_Rfvfvf = new Rfvfvf('a', 'b')
-val i_Rfvfvf = new Rfvfvf(1, 2)
-assert(1 == i_Rfvfvf.`a b`)
-assert(2 == i_Rfvfvf.a)
-assert('a' == ch_Rfvfvf.`a b`)
-assert('b' == ch_Rfvfvf.a)
+val ch_Rvf_vf = new Rvf_vf('a', 'b')
+val i_Rvf_vf = new Rvf_vf(1, 2)
+assert(1 == i_Rvf_vf.`a b`)
+assert(2 == i_Rvf_vf.a)
+assert('a' == ch_Rvf_vf.`a b`)
+assert('b' == ch_Rvf_vf.a)
 
 
-val ch_Rfvfnt = new Rfvfnt('a', 'b')
-val i_Rfvfnt = new Rfvfnt(1, 2)
-assert(1 == i_Rfvfnt.`a b`)
-assert('a' == ch_Rfvfnt.`a b`)
-assert(2 == i_Rfvfnt.p2)
-assert('b' == ch_Rfvfnt.p2)
+val ch_Rvf_nt = new Rvf_nt('a', 'b')
+val i_Rvf_nt = new Rvf_nt(1, 2)
+assert(1 == i_Rvf_nt.`a b`)
+assert('a' == ch_Rvf_nt.`a b`)
+assert(2 == i_Rvf_nt.p2)
+assert('b' == ch_Rvf_nt.p2)
 
 
-val ch_Rfvfnf = new Rfvfnf('a', 'b')
-val i_Rfvfnf = new Rfvfnf(1, 2)
-assert(1 == i_Rfvfnf.`a b`)
-assert('a' == ch_Rfvfnf.`a b`)
+val ch_Rvf_nf = new Rvf_nf('a', 'b')
+val i_Rvf_nf = new Rvf_nf(1, 2)
+assert(1 == i_Rvf_nf.`a b`)
+assert('a' == ch_Rvf_nf.`a b`)
 
 
-val ch_Rfntpvt = new Rfntpvt('a', 'b')
-val i_Rfntpvt = new Rfntpvt(1, 2)
-assert(1 == i_Rfntpvt.p1)
-assert(2 == i_Rfntpvt.p2)
-assert('a' == ch_Rfntpvt.p1)
-assert('b' == ch_Rfntpvt.p2)
+val ch_Rnt_pvt = new Rnt_pvt('a', 'b')
+val i_Rnt_pvt = new Rnt_pvt(1, 2)
+assert(1 == i_Rnt_pvt.p1)
+assert(2 == i_Rnt_pvt.p2)
+assert('a' == ch_Rnt_pvt.p1)
+assert('b' == ch_Rnt_pvt.p2)
 
 
-val ch_Rfntpvf = new Rfntpvf('a', 'b')
-val i_Rfntpvf = new Rfntpvf(1, 2)
-assert(1 == i_Rfntpvf.p1)
-assert('a' == ch_Rfntpvf.p1)
+val ch_Rnt_pvf = new Rnt_pvf('a', 'b')
+val i_Rnt_pvf = new Rnt_pvf(1, 2)
+assert(1 == i_Rnt_pvf.p1)
+assert('a' == ch_Rnt_pvf.p1)
 
 
-val ch_Rfntvt = new Rfntvt('a', 'b')
-val i_Rfntvt = new Rfntvt(1, 2)
-assert(2 == i_Rfntvt.a)
-assert('b' == ch_Rfntvt.a)
-assert(1 == i_Rfntvt.p1)
-assert(2 == i_Rfntvt.p2)
-assert('a' == ch_Rfntvt.p1)
-assert('b' == ch_Rfntvt.p2)
+val ch_Rnt_vt = new Rnt_vt('a', 'b')
+val i_Rnt_vt = new Rnt_vt(1, 2)
+assert(2 == i_Rnt_vt.a)
+assert('b' == ch_Rnt_vt.a)
+assert(1 == i_Rnt_vt.p1)
+assert(2 == i_Rnt_vt.p2)
+assert('a' == ch_Rnt_vt.p1)
+assert('b' == ch_Rnt_vt.p2)
 
 
-val ch_Rfntvf = new Rfntvf('a', 'b')
-val i_Rfntvf = new Rfntvf(1, 2)
-assert(2 == i_Rfntvf.a)
-assert('b' == ch_Rfntvf.a)
-assert(1 == i_Rfntvf.p1)
-assert('a' == ch_Rfntvf.p1)
+val ch_Rnt_vf = new Rnt_vf('a', 'b')
+val i_Rnt_vf = new Rnt_vf(1, 2)
+assert(2 == i_Rnt_vf.a)
+assert('b' == ch_Rnt_vf.a)
+assert(1 == i_Rnt_vf.p1)
+assert('a' == ch_Rnt_vf.p1)
 
 
-val ch_Rfntnt = new Rfntnt('a', 'b')
-val i_Rfntnt = new Rfntnt(1, 2)
-assert(1 == i_Rfntnt.p1)
-assert(2 == i_Rfntnt.p2)
-assert('a' == ch_Rfntnt.p1)
-assert('b' == ch_Rfntnt.p2)
+val ch_Rnt_nt = new Rnt_nt('a', 'b')
+val i_Rnt_nt = new Rnt_nt(1, 2)
+assert(1 == i_Rnt_nt.p1)
+assert(2 == i_Rnt_nt.p2)
+assert('a' == ch_Rnt_nt.p1)
+assert('b' == ch_Rnt_nt.p2)
 
 
-val ch_Rfntnf = new Rfntnf('a', 'b')
-val i_Rfntnf = new Rfntnf(1, 2)
-assert(1 == i_Rfntnf.p1)
-assert('a' == ch_Rfntnf.p1)
+val ch_Rnt_nf = new Rnt_nf('a', 'b')
+val i_Rnt_nf = new Rnt_nf(1, 2)
+assert(1 == i_Rnt_nf.p1)
+assert('a' == ch_Rnt_nf.p1)
 
 
-val ch_Rfnfpvt = new Rfnfpvt('a', 'b')
-val i_Rfnfpvt = new Rfnfpvt(1, 2)
-assert(2 == i_Rfnfpvt.p2)
-assert('b' == ch_Rfnfpvt.p2)
+val ch_Rnf_pvt = new Rnf_pvt('a', 'b')
+val i_Rnf_pvt = new Rnf_pvt(1, 2)
+assert(2 == i_Rnf_pvt.p2)
+assert('b' == ch_Rnf_pvt.p2)
 
 
-val ch_Rfnfpvf = new Rfnfpvf('a', 'b')
-val i_Rfnfpvf = new Rfnfpvf(1, 2)
+val ch_Rnf_pvf = new Rnf_pvf('a', 'b')
+val i_Rnf_pvf = new Rnf_pvf(1, 2)
 
 
-val ch_Rfnfvt = new Rfnfvt('a', 'b')
-val i_Rfnfvt = new Rfnfvt(1, 2)
-assert(2 == i_Rfnfvt.a)
-assert('b' == ch_Rfnfvt.a)
-assert(2 == i_Rfnfvt.p2)
-assert('b' == ch_Rfnfvt.p2)
+val ch_Rnf_vt = new Rnf_vt('a', 'b')
+val i_Rnf_vt = new Rnf_vt(1, 2)
+assert(2 == i_Rnf_vt.a)
+assert('b' == ch_Rnf_vt.a)
+assert(2 == i_Rnf_vt.p2)
+assert('b' == ch_Rnf_vt.p2)
 
 
-val ch_Rfnfvf = new Rfnfvf('a', 'b')
-val i_Rfnfvf = new Rfnfvf(1, 2)
-assert(2 == i_Rfnfvf.a)
-assert('b' == ch_Rfnfvf.a)
+val ch_Rnf_vf = new Rnf_vf('a', 'b')
+val i_Rnf_vf = new Rnf_vf(1, 2)
+assert(2 == i_Rnf_vf.a)
+assert('b' == ch_Rnf_vf.a)
 
 
-val ch_Rfnfnt = new Rfnfnt('a', 'b')
-val i_Rfnfnt = new Rfnfnt(1, 2)
-assert(2 == i_Rfnfnt.p2)
-assert('b' == ch_Rfnfnt.p2)
+val ch_Rnf_nt = new Rnf_nt('a', 'b')
+val i_Rnf_nt = new Rnf_nt(1, 2)
+assert(2 == i_Rnf_nt.p2)
+assert('b' == ch_Rnf_nt.p2)
 
 
-val ch_Rfnfnf = new Rfnfnf('a', 'b')
-val i_Rfnfnf = new Rfnfnf(1, 2)
+val ch_Rnf_nf = new Rnf_nf('a', 'b')
+val i_Rnf_nf = new Rnf_nf(1, 2)
 
 
 }}
diff --git a/test/files/run/t8831_many/Tests_2.scala b/test/files/run/t8831_many/Tests_2.scala
index fba69ecabe56..65ff1f0bbab2 100644
--- a/test/files/run/t8831_many/Tests_2.scala
+++ b/test/files/run/t8831_many/Tests_2.scala
@@ -1,1488 +1,831 @@
 object Test extends App {
 
-val ch_Ctpvtpvt = new Ctpvtpvt('a', 'b')
-val i_Ctpvtpvt = new Ctpvtpvt(1, 2)
-val Ctpvtpvt(extracted1i_Ctpvtpvt, extracted2i_Ctpvtpvt) = i_Ctpvtpvt
-val Ctpvtpvt(extracted1ch_Ctpvtpvt, extracted2ch_Ctpvtpvt) = ch_Ctpvtpvt
-assert(1 == extracted1i_Ctpvtpvt)
-assert(2 == extracted2i_Ctpvtpvt)
-assert('a' == extracted1ch_Ctpvtpvt)
-assert('b' == extracted2ch_Ctpvtpvt)
-
-assert(1 == i_Ctpvtpvt.p1)
-assert(2 == i_Ctpvtpvt.p2)
-assert('a' == ch_Ctpvtpvt.p1)
-assert('b' == ch_Ctpvtpvt.p2)
-
-
-val ch_Ctpvtpvf = new Ctpvtpvf('a', 'b')
-val i_Ctpvtpvf = new Ctpvtpvf(1, 2)
-val Ctpvtpvf(extracted1i_Ctpvtpvf, extracted2i_Ctpvtpvf) = i_Ctpvtpvf
-val Ctpvtpvf(extracted1ch_Ctpvtpvf, extracted2ch_Ctpvtpvf) = ch_Ctpvtpvf
-assert(1 == extracted1i_Ctpvtpvf)
-assert(2 == extracted2i_Ctpvtpvf)
-assert('a' == extracted1ch_Ctpvtpvf)
-assert('b' == extracted2ch_Ctpvtpvf)
-
-assert(1 == i_Ctpvtpvf.p1)
-assert('a' == ch_Ctpvtpvf.p1)
-
-
-val ch_Ctpvtvt = new Ctpvtvt('a', 'b')
-val i_Ctpvtvt = new Ctpvtvt(1, 2)
-val Ctpvtvt(extracted1i_Ctpvtvt, extracted2i_Ctpvtvt) = i_Ctpvtvt
-val Ctpvtvt(extracted1ch_Ctpvtvt, extracted2ch_Ctpvtvt) = ch_Ctpvtvt
-assert(1 == extracted1i_Ctpvtvt)
-assert(2 == extracted2i_Ctpvtvt)
-assert('a' == extracted1ch_Ctpvtvt)
-assert('b' == extracted2ch_Ctpvtvt)
-
-assert(2 == i_Ctpvtvt.a)
-assert('b' == ch_Ctpvtvt.a)
-assert(1 == i_Ctpvtvt.p1)
-assert(2 == i_Ctpvtvt.p2)
-assert('a' == ch_Ctpvtvt.p1)
-assert('b' == ch_Ctpvtvt.p2)
-
-
-val ch_Ctpvtvf = new Ctpvtvf('a', 'b')
-val i_Ctpvtvf = new Ctpvtvf(1, 2)
-val Ctpvtvf(extracted1i_Ctpvtvf, extracted2i_Ctpvtvf) = i_Ctpvtvf
-val Ctpvtvf(extracted1ch_Ctpvtvf, extracted2ch_Ctpvtvf) = ch_Ctpvtvf
-assert(1 == extracted1i_Ctpvtvf)
-assert(2 == extracted2i_Ctpvtvf)
-assert('a' == extracted1ch_Ctpvtvf)
-assert('b' == extracted2ch_Ctpvtvf)
-
-assert(2 == i_Ctpvtvf.a)
-assert('b' == ch_Ctpvtvf.a)
-assert(1 == i_Ctpvtvf.p1)
-assert('a' == ch_Ctpvtvf.p1)
-
-
-val ch_Ctpvtnt = new Ctpvtnt('a', 'b')
-val i_Ctpvtnt = new Ctpvtnt(1, 2)
-val Ctpvtnt(extracted1i_Ctpvtnt, extracted2i_Ctpvtnt) = i_Ctpvtnt
-val Ctpvtnt(extracted1ch_Ctpvtnt, extracted2ch_Ctpvtnt) = ch_Ctpvtnt
-assert(1 == extracted1i_Ctpvtnt)
-assert(2 == extracted2i_Ctpvtnt)
-assert('a' == extracted1ch_Ctpvtnt)
-assert('b' == extracted2ch_Ctpvtnt)
-
-assert(2 == i_Ctpvtnt.a)
-assert('b' == ch_Ctpvtnt.a)
-assert(1 == i_Ctpvtnt.p1)
-assert(2 == i_Ctpvtnt.p2)
-assert('a' == ch_Ctpvtnt.p1)
-assert('b' == ch_Ctpvtnt.p2)
-
-
-val ch_Ctpvtnf = new Ctpvtnf('a', 'b')
-val i_Ctpvtnf = new Ctpvtnf(1, 2)
-val Ctpvtnf(extracted1i_Ctpvtnf, extracted2i_Ctpvtnf) = i_Ctpvtnf
-val Ctpvtnf(extracted1ch_Ctpvtnf, extracted2ch_Ctpvtnf) = ch_Ctpvtnf
-assert(1 == extracted1i_Ctpvtnf)
-assert(2 == extracted2i_Ctpvtnf)
-assert('a' == extracted1ch_Ctpvtnf)
-assert('b' == extracted2ch_Ctpvtnf)
-
-assert(2 == i_Ctpvtnf.a)
-assert('b' == ch_Ctpvtnf.a)
-assert(1 == i_Ctpvtnf.p1)
-assert('a' == ch_Ctpvtnf.p1)
-
-
-val ch_Ctpvfpvt = new Ctpvfpvt('a', 'b')
-val i_Ctpvfpvt = new Ctpvfpvt(1, 2)
-val Ctpvfpvt(extracted1i_Ctpvfpvt, extracted2i_Ctpvfpvt) = i_Ctpvfpvt
-val Ctpvfpvt(extracted1ch_Ctpvfpvt, extracted2ch_Ctpvfpvt) = ch_Ctpvfpvt
-assert(1 == extracted1i_Ctpvfpvt)
-assert(2 == extracted2i_Ctpvfpvt)
-assert('a' == extracted1ch_Ctpvfpvt)
-assert('b' == extracted2ch_Ctpvfpvt)
-
-assert(2 == i_Ctpvfpvt.p2)
-assert('b' == ch_Ctpvfpvt.p2)
-
-
-val ch_Ctpvfvt = new Ctpvfvt('a', 'b')
-val i_Ctpvfvt = new Ctpvfvt(1, 2)
-val Ctpvfvt(extracted1i_Ctpvfvt, extracted2i_Ctpvfvt) = i_Ctpvfvt
-val Ctpvfvt(extracted1ch_Ctpvfvt, extracted2ch_Ctpvfvt) = ch_Ctpvfvt
-assert(1 == extracted1i_Ctpvfvt)
-assert(2 == extracted2i_Ctpvfvt)
-assert('a' == extracted1ch_Ctpvfvt)
-assert('b' == extracted2ch_Ctpvfvt)
-
-assert(2 == i_Ctpvfvt.a)
-assert('b' == ch_Ctpvfvt.a)
-assert(2 == i_Ctpvfvt.p2)
-assert('b' == ch_Ctpvfvt.p2)
-
-
-val ch_Ctpvfnt = new Ctpvfnt('a', 'b')
-val i_Ctpvfnt = new Ctpvfnt(1, 2)
-val Ctpvfnt(extracted1i_Ctpvfnt, extracted2i_Ctpvfnt) = i_Ctpvfnt
-val Ctpvfnt(extracted1ch_Ctpvfnt, extracted2ch_Ctpvfnt) = ch_Ctpvfnt
-assert(1 == extracted1i_Ctpvfnt)
-assert(2 == extracted2i_Ctpvfnt)
-assert('a' == extracted1ch_Ctpvfnt)
-assert('b' == extracted2ch_Ctpvfnt)
-
-assert(2 == i_Ctpvfnt.a)
-assert('b' == ch_Ctpvfnt.a)
-assert(2 == i_Ctpvfnt.p2)
-assert('b' == ch_Ctpvfnt.p2)
-
-
-val ch_Ctvtpvt = new Ctvtpvt('a', 'b')
-val i_Ctvtpvt = new Ctvtpvt(1, 2)
-val Ctvtpvt(extracted1i_Ctvtpvt, extracted2i_Ctvtpvt) = i_Ctvtpvt
-val Ctvtpvt(extracted1ch_Ctvtpvt, extracted2ch_Ctvtpvt) = ch_Ctvtpvt
-assert(1 == extracted1i_Ctvtpvt)
-assert(2 == extracted2i_Ctvtpvt)
-assert('a' == extracted1ch_Ctvtpvt)
-assert('b' == extracted2ch_Ctvtpvt)
-
-assert(1 == i_Ctvtpvt.`a b`)
-assert('a' == ch_Ctvtpvt.`a b`)
-assert(1 == i_Ctvtpvt.p1)
-assert(2 == i_Ctvtpvt.p2)
-assert('a' == ch_Ctvtpvt.p1)
-assert('b' == ch_Ctvtpvt.p2)
-
-
-val ch_Ctvtpvf = new Ctvtpvf('a', 'b')
-val i_Ctvtpvf = new Ctvtpvf(1, 2)
-val Ctvtpvf(extracted1i_Ctvtpvf, extracted2i_Ctvtpvf) = i_Ctvtpvf
-val Ctvtpvf(extracted1ch_Ctvtpvf, extracted2ch_Ctvtpvf) = ch_Ctvtpvf
-assert(1 == extracted1i_Ctvtpvf)
-assert(2 == extracted2i_Ctvtpvf)
-assert('a' == extracted1ch_Ctvtpvf)
-assert('b' == extracted2ch_Ctvtpvf)
-
-assert(1 == i_Ctvtpvf.`a b`)
-assert('a' == ch_Ctvtpvf.`a b`)
-assert(1 == i_Ctvtpvf.p1)
-assert('a' == ch_Ctvtpvf.p1)
-
-
-val ch_Ctvtvt = new Ctvtvt('a', 'b')
-val i_Ctvtvt = new Ctvtvt(1, 2)
-val Ctvtvt(extracted1i_Ctvtvt, extracted2i_Ctvtvt) = i_Ctvtvt
-val Ctvtvt(extracted1ch_Ctvtvt, extracted2ch_Ctvtvt) = ch_Ctvtvt
-assert(1 == extracted1i_Ctvtvt)
-assert(2 == extracted2i_Ctvtvt)
-assert('a' == extracted1ch_Ctvtvt)
-assert('b' == extracted2ch_Ctvtvt)
-
-assert(1 == i_Ctvtvt.`a b`)
-assert(2 == i_Ctvtvt.a)
-assert('a' == ch_Ctvtvt.`a b`)
-assert('b' == ch_Ctvtvt.a)
-assert(1 == i_Ctvtvt.p1)
-assert(2 == i_Ctvtvt.p2)
-assert('a' == ch_Ctvtvt.p1)
-assert('b' == ch_Ctvtvt.p2)
-
-
-val ch_Ctvtvf = new Ctvtvf('a', 'b')
-val i_Ctvtvf = new Ctvtvf(1, 2)
-val Ctvtvf(extracted1i_Ctvtvf, extracted2i_Ctvtvf) = i_Ctvtvf
-val Ctvtvf(extracted1ch_Ctvtvf, extracted2ch_Ctvtvf) = ch_Ctvtvf
-assert(1 == extracted1i_Ctvtvf)
-assert(2 == extracted2i_Ctvtvf)
-assert('a' == extracted1ch_Ctvtvf)
-assert('b' == extracted2ch_Ctvtvf)
-
-assert(1 == i_Ctvtvf.`a b`)
-assert(2 == i_Ctvtvf.a)
-assert('a' == ch_Ctvtvf.`a b`)
-assert('b' == ch_Ctvtvf.a)
-assert(1 == i_Ctvtvf.p1)
-assert('a' == ch_Ctvtvf.p1)
-
-
-val ch_Ctvtnt = new Ctvtnt('a', 'b')
-val i_Ctvtnt = new Ctvtnt(1, 2)
-val Ctvtnt(extracted1i_Ctvtnt, extracted2i_Ctvtnt) = i_Ctvtnt
-val Ctvtnt(extracted1ch_Ctvtnt, extracted2ch_Ctvtnt) = ch_Ctvtnt
-assert(1 == extracted1i_Ctvtnt)
-assert(2 == extracted2i_Ctvtnt)
-assert('a' == extracted1ch_Ctvtnt)
-assert('b' == extracted2ch_Ctvtnt)
-
-assert(1 == i_Ctvtnt.`a b`)
-assert(2 == i_Ctvtnt.a)
-assert('a' == ch_Ctvtnt.`a b`)
-assert('b' == ch_Ctvtnt.a)
-assert(1 == i_Ctvtnt.p1)
-assert(2 == i_Ctvtnt.p2)
-assert('a' == ch_Ctvtnt.p1)
-assert('b' == ch_Ctvtnt.p2)
-
-
-val ch_Ctvtnf = new Ctvtnf('a', 'b')
-val i_Ctvtnf = new Ctvtnf(1, 2)
-val Ctvtnf(extracted1i_Ctvtnf, extracted2i_Ctvtnf) = i_Ctvtnf
-val Ctvtnf(extracted1ch_Ctvtnf, extracted2ch_Ctvtnf) = ch_Ctvtnf
-assert(1 == extracted1i_Ctvtnf)
-assert(2 == extracted2i_Ctvtnf)
-assert('a' == extracted1ch_Ctvtnf)
-assert('b' == extracted2ch_Ctvtnf)
-
-assert(1 == i_Ctvtnf.`a b`)
-assert(2 == i_Ctvtnf.a)
-assert('a' == ch_Ctvtnf.`a b`)
-assert('b' == ch_Ctvtnf.a)
-assert(1 == i_Ctvtnf.p1)
-assert('a' == ch_Ctvtnf.p1)
-
-
-val ch_Ctvfpvt = new Ctvfpvt('a', 'b')
-val i_Ctvfpvt = new Ctvfpvt(1, 2)
-val Ctvfpvt(extracted1i_Ctvfpvt, extracted2i_Ctvfpvt) = i_Ctvfpvt
-val Ctvfpvt(extracted1ch_Ctvfpvt, extracted2ch_Ctvfpvt) = ch_Ctvfpvt
-assert(1 == extracted1i_Ctvfpvt)
-assert(2 == extracted2i_Ctvfpvt)
-assert('a' == extracted1ch_Ctvfpvt)
-assert('b' == extracted2ch_Ctvfpvt)
-
-assert(1 == i_Ctvfpvt.`a b`)
-assert('a' == ch_Ctvfpvt.`a b`)
-assert(2 == i_Ctvfpvt.p2)
-assert('b' == ch_Ctvfpvt.p2)
-
-
-val ch_Ctvfvt = new Ctvfvt('a', 'b')
-val i_Ctvfvt = new Ctvfvt(1, 2)
-val Ctvfvt(extracted1i_Ctvfvt, extracted2i_Ctvfvt) = i_Ctvfvt
-val Ctvfvt(extracted1ch_Ctvfvt, extracted2ch_Ctvfvt) = ch_Ctvfvt
-assert(1 == extracted1i_Ctvfvt)
-assert(2 == extracted2i_Ctvfvt)
-assert('a' == extracted1ch_Ctvfvt)
-assert('b' == extracted2ch_Ctvfvt)
-
-assert(1 == i_Ctvfvt.`a b`)
-assert(2 == i_Ctvfvt.a)
-assert('a' == ch_Ctvfvt.`a b`)
-assert('b' == ch_Ctvfvt.a)
-assert(2 == i_Ctvfvt.p2)
-assert('b' == ch_Ctvfvt.p2)
-
-
-val ch_Ctvfnt = new Ctvfnt('a', 'b')
-val i_Ctvfnt = new Ctvfnt(1, 2)
-val Ctvfnt(extracted1i_Ctvfnt, extracted2i_Ctvfnt) = i_Ctvfnt
-val Ctvfnt(extracted1ch_Ctvfnt, extracted2ch_Ctvfnt) = ch_Ctvfnt
-assert(1 == extracted1i_Ctvfnt)
-assert(2 == extracted2i_Ctvfnt)
-assert('a' == extracted1ch_Ctvfnt)
-assert('b' == extracted2ch_Ctvfnt)
-
-assert(1 == i_Ctvfnt.`a b`)
-assert(2 == i_Ctvfnt.a)
-assert('a' == ch_Ctvfnt.`a b`)
-assert('b' == ch_Ctvfnt.a)
-assert(2 == i_Ctvfnt.p2)
-assert('b' == ch_Ctvfnt.p2)
-
-
-val ch_Ctntpvt = new Ctntpvt('a', 'b')
-val i_Ctntpvt = new Ctntpvt(1, 2)
-val Ctntpvt(extracted1i_Ctntpvt, extracted2i_Ctntpvt) = i_Ctntpvt
-val Ctntpvt(extracted1ch_Ctntpvt, extracted2ch_Ctntpvt) = ch_Ctntpvt
-assert(1 == extracted1i_Ctntpvt)
-assert(2 == extracted2i_Ctntpvt)
-assert('a' == extracted1ch_Ctntpvt)
-assert('b' == extracted2ch_Ctntpvt)
-
-assert(1 == i_Ctntpvt.`a b`)
-assert('a' == ch_Ctntpvt.`a b`)
-assert(1 == i_Ctntpvt.p1)
-assert(2 == i_Ctntpvt.p2)
-assert('a' == ch_Ctntpvt.p1)
-assert('b' == ch_Ctntpvt.p2)
-
-
-val ch_Ctntpvf = new Ctntpvf('a', 'b')
-val i_Ctntpvf = new Ctntpvf(1, 2)
-val Ctntpvf(extracted1i_Ctntpvf, extracted2i_Ctntpvf) = i_Ctntpvf
-val Ctntpvf(extracted1ch_Ctntpvf, extracted2ch_Ctntpvf) = ch_Ctntpvf
-assert(1 == extracted1i_Ctntpvf)
-assert(2 == extracted2i_Ctntpvf)
-assert('a' == extracted1ch_Ctntpvf)
-assert('b' == extracted2ch_Ctntpvf)
-
-assert(1 == i_Ctntpvf.`a b`)
-assert('a' == ch_Ctntpvf.`a b`)
-assert(1 == i_Ctntpvf.p1)
-assert('a' == ch_Ctntpvf.p1)
-
-
-val ch_Ctntvt = new Ctntvt('a', 'b')
-val i_Ctntvt = new Ctntvt(1, 2)
-val Ctntvt(extracted1i_Ctntvt, extracted2i_Ctntvt) = i_Ctntvt
-val Ctntvt(extracted1ch_Ctntvt, extracted2ch_Ctntvt) = ch_Ctntvt
-assert(1 == extracted1i_Ctntvt)
-assert(2 == extracted2i_Ctntvt)
-assert('a' == extracted1ch_Ctntvt)
-assert('b' == extracted2ch_Ctntvt)
-
-assert(1 == i_Ctntvt.`a b`)
-assert(2 == i_Ctntvt.a)
-assert('a' == ch_Ctntvt.`a b`)
-assert('b' == ch_Ctntvt.a)
-assert(1 == i_Ctntvt.p1)
-assert(2 == i_Ctntvt.p2)
-assert('a' == ch_Ctntvt.p1)
-assert('b' == ch_Ctntvt.p2)
-
-
-val ch_Ctntvf = new Ctntvf('a', 'b')
-val i_Ctntvf = new Ctntvf(1, 2)
-val Ctntvf(extracted1i_Ctntvf, extracted2i_Ctntvf) = i_Ctntvf
-val Ctntvf(extracted1ch_Ctntvf, extracted2ch_Ctntvf) = ch_Ctntvf
-assert(1 == extracted1i_Ctntvf)
-assert(2 == extracted2i_Ctntvf)
-assert('a' == extracted1ch_Ctntvf)
-assert('b' == extracted2ch_Ctntvf)
-
-assert(1 == i_Ctntvf.`a b`)
-assert(2 == i_Ctntvf.a)
-assert('a' == ch_Ctntvf.`a b`)
-assert('b' == ch_Ctntvf.a)
-assert(1 == i_Ctntvf.p1)
-assert('a' == ch_Ctntvf.p1)
-
-
-val ch_Ctntnt = new Ctntnt('a', 'b')
-val i_Ctntnt = new Ctntnt(1, 2)
-val Ctntnt(extracted1i_Ctntnt, extracted2i_Ctntnt) = i_Ctntnt
-val Ctntnt(extracted1ch_Ctntnt, extracted2ch_Ctntnt) = ch_Ctntnt
-assert(1 == extracted1i_Ctntnt)
-assert(2 == extracted2i_Ctntnt)
-assert('a' == extracted1ch_Ctntnt)
-assert('b' == extracted2ch_Ctntnt)
-
-assert(1 == i_Ctntnt.`a b`)
-assert(2 == i_Ctntnt.a)
-assert('a' == ch_Ctntnt.`a b`)
-assert('b' == ch_Ctntnt.a)
-assert(1 == i_Ctntnt.p1)
-assert(2 == i_Ctntnt.p2)
-assert('a' == ch_Ctntnt.p1)
-assert('b' == ch_Ctntnt.p2)
-
-
-val ch_Ctntnf = new Ctntnf('a', 'b')
-val i_Ctntnf = new Ctntnf(1, 2)
-val Ctntnf(extracted1i_Ctntnf, extracted2i_Ctntnf) = i_Ctntnf
-val Ctntnf(extracted1ch_Ctntnf, extracted2ch_Ctntnf) = ch_Ctntnf
-assert(1 == extracted1i_Ctntnf)
-assert(2 == extracted2i_Ctntnf)
-assert('a' == extracted1ch_Ctntnf)
-assert('b' == extracted2ch_Ctntnf)
-
-assert(1 == i_Ctntnf.`a b`)
-assert(2 == i_Ctntnf.a)
-assert('a' == ch_Ctntnf.`a b`)
-assert('b' == ch_Ctntnf.a)
-assert(1 == i_Ctntnf.p1)
-assert('a' == ch_Ctntnf.p1)
-
-
-val ch_Ctnfpvt = new Ctnfpvt('a', 'b')
-val i_Ctnfpvt = new Ctnfpvt(1, 2)
-val Ctnfpvt(extracted1i_Ctnfpvt, extracted2i_Ctnfpvt) = i_Ctnfpvt
-val Ctnfpvt(extracted1ch_Ctnfpvt, extracted2ch_Ctnfpvt) = ch_Ctnfpvt
-assert(1 == extracted1i_Ctnfpvt)
-assert(2 == extracted2i_Ctnfpvt)
-assert('a' == extracted1ch_Ctnfpvt)
-assert('b' == extracted2ch_Ctnfpvt)
-
-assert(1 == i_Ctnfpvt.`a b`)
-assert('a' == ch_Ctnfpvt.`a b`)
-assert(2 == i_Ctnfpvt.p2)
-assert('b' == ch_Ctnfpvt.p2)
-
-
-val ch_Ctnfvt = new Ctnfvt('a', 'b')
-val i_Ctnfvt = new Ctnfvt(1, 2)
-val Ctnfvt(extracted1i_Ctnfvt, extracted2i_Ctnfvt) = i_Ctnfvt
-val Ctnfvt(extracted1ch_Ctnfvt, extracted2ch_Ctnfvt) = ch_Ctnfvt
-assert(1 == extracted1i_Ctnfvt)
-assert(2 == extracted2i_Ctnfvt)
-assert('a' == extracted1ch_Ctnfvt)
-assert('b' == extracted2ch_Ctnfvt)
-
-assert(1 == i_Ctnfvt.`a b`)
-assert(2 == i_Ctnfvt.a)
-assert('a' == ch_Ctnfvt.`a b`)
-assert('b' == ch_Ctnfvt.a)
-assert(2 == i_Ctnfvt.p2)
-assert('b' == ch_Ctnfvt.p2)
-
-
-val ch_Ctnfnt = new Ctnfnt('a', 'b')
-val i_Ctnfnt = new Ctnfnt(1, 2)
-val Ctnfnt(extracted1i_Ctnfnt, extracted2i_Ctnfnt) = i_Ctnfnt
-val Ctnfnt(extracted1ch_Ctnfnt, extracted2ch_Ctnfnt) = ch_Ctnfnt
-assert(1 == extracted1i_Ctnfnt)
-assert(2 == extracted2i_Ctnfnt)
-assert('a' == extracted1ch_Ctnfnt)
-assert('b' == extracted2ch_Ctnfnt)
-
-assert(1 == i_Ctnfnt.`a b`)
-assert(2 == i_Ctnfnt.a)
-assert('a' == ch_Ctnfnt.`a b`)
-assert('b' == ch_Ctnfnt.a)
-assert(2 == i_Ctnfnt.p2)
-assert('b' == ch_Ctnfnt.p2)
-
-
-val ch_Cfpvtpvt = new Cfpvtpvt('a', 'b')
-val i_Cfpvtpvt = new Cfpvtpvt(1, 2)
-val Cfpvtpvt(extracted1i_Cfpvtpvt, extracted2i_Cfpvtpvt) = i_Cfpvtpvt
-val Cfpvtpvt(extracted1ch_Cfpvtpvt, extracted2ch_Cfpvtpvt) = ch_Cfpvtpvt
-assert(1 == extracted1i_Cfpvtpvt)
-assert(2 == extracted2i_Cfpvtpvt)
-assert('a' == extracted1ch_Cfpvtpvt)
-assert('b' == extracted2ch_Cfpvtpvt)
-
-assert(1 == i_Cfpvtpvt.p1)
-assert(2 == i_Cfpvtpvt.p2)
-assert('a' == ch_Cfpvtpvt.p1)
-assert('b' == ch_Cfpvtpvt.p2)
-
-
-val ch_Cfpvtpvf = new Cfpvtpvf('a', 'b')
-val i_Cfpvtpvf = new Cfpvtpvf(1, 2)
-val Cfpvtpvf(extracted1i_Cfpvtpvf, extracted2i_Cfpvtpvf) = i_Cfpvtpvf
-val Cfpvtpvf(extracted1ch_Cfpvtpvf, extracted2ch_Cfpvtpvf) = ch_Cfpvtpvf
-assert(1 == extracted1i_Cfpvtpvf)
-assert(2 == extracted2i_Cfpvtpvf)
-assert('a' == extracted1ch_Cfpvtpvf)
-assert('b' == extracted2ch_Cfpvtpvf)
-
-assert(1 == i_Cfpvtpvf.p1)
-assert('a' == ch_Cfpvtpvf.p1)
-
-
-val ch_Cfpvtvt = new Cfpvtvt('a', 'b')
-val i_Cfpvtvt = new Cfpvtvt(1, 2)
-val Cfpvtvt(extracted1i_Cfpvtvt, extracted2i_Cfpvtvt) = i_Cfpvtvt
-val Cfpvtvt(extracted1ch_Cfpvtvt, extracted2ch_Cfpvtvt) = ch_Cfpvtvt
-assert(1 == extracted1i_Cfpvtvt)
-assert(2 == extracted2i_Cfpvtvt)
-assert('a' == extracted1ch_Cfpvtvt)
-assert('b' == extracted2ch_Cfpvtvt)
-
-assert(2 == i_Cfpvtvt.a)
-assert('b' == ch_Cfpvtvt.a)
-assert(1 == i_Cfpvtvt.p1)
-assert(2 == i_Cfpvtvt.p2)
-assert('a' == ch_Cfpvtvt.p1)
-assert('b' == ch_Cfpvtvt.p2)
-
-
-val ch_Cfpvtvf = new Cfpvtvf('a', 'b')
-val i_Cfpvtvf = new Cfpvtvf(1, 2)
-val Cfpvtvf(extracted1i_Cfpvtvf, extracted2i_Cfpvtvf) = i_Cfpvtvf
-val Cfpvtvf(extracted1ch_Cfpvtvf, extracted2ch_Cfpvtvf) = ch_Cfpvtvf
-assert(1 == extracted1i_Cfpvtvf)
-assert(2 == extracted2i_Cfpvtvf)
-assert('a' == extracted1ch_Cfpvtvf)
-assert('b' == extracted2ch_Cfpvtvf)
-
-assert(2 == i_Cfpvtvf.a)
-assert('b' == ch_Cfpvtvf.a)
-assert(1 == i_Cfpvtvf.p1)
-assert('a' == ch_Cfpvtvf.p1)
-
-
-val ch_Cfpvtnt = new Cfpvtnt('a', 'b')
-val i_Cfpvtnt = new Cfpvtnt(1, 2)
-val Cfpvtnt(extracted1i_Cfpvtnt, extracted2i_Cfpvtnt) = i_Cfpvtnt
-val Cfpvtnt(extracted1ch_Cfpvtnt, extracted2ch_Cfpvtnt) = ch_Cfpvtnt
-assert(1 == extracted1i_Cfpvtnt)
-assert(2 == extracted2i_Cfpvtnt)
-assert('a' == extracted1ch_Cfpvtnt)
-assert('b' == extracted2ch_Cfpvtnt)
-
-assert(2 == i_Cfpvtnt.a)
-assert('b' == ch_Cfpvtnt.a)
-assert(1 == i_Cfpvtnt.p1)
-assert(2 == i_Cfpvtnt.p2)
-assert('a' == ch_Cfpvtnt.p1)
-assert('b' == ch_Cfpvtnt.p2)
-
-
-val ch_Cfpvtnf = new Cfpvtnf('a', 'b')
-val i_Cfpvtnf = new Cfpvtnf(1, 2)
-val Cfpvtnf(extracted1i_Cfpvtnf, extracted2i_Cfpvtnf) = i_Cfpvtnf
-val Cfpvtnf(extracted1ch_Cfpvtnf, extracted2ch_Cfpvtnf) = ch_Cfpvtnf
-assert(1 == extracted1i_Cfpvtnf)
-assert(2 == extracted2i_Cfpvtnf)
-assert('a' == extracted1ch_Cfpvtnf)
-assert('b' == extracted2ch_Cfpvtnf)
-
-assert(2 == i_Cfpvtnf.a)
-assert('b' == ch_Cfpvtnf.a)
-assert(1 == i_Cfpvtnf.p1)
-assert('a' == ch_Cfpvtnf.p1)
-
-
-val ch_Cfpvfpvt = new Cfpvfpvt('a', 'b')
-val i_Cfpvfpvt = new Cfpvfpvt(1, 2)
-val Cfpvfpvt(extracted1i_Cfpvfpvt, extracted2i_Cfpvfpvt) = i_Cfpvfpvt
-val Cfpvfpvt(extracted1ch_Cfpvfpvt, extracted2ch_Cfpvfpvt) = ch_Cfpvfpvt
-assert(1 == extracted1i_Cfpvfpvt)
-assert(2 == extracted2i_Cfpvfpvt)
-assert('a' == extracted1ch_Cfpvfpvt)
-assert('b' == extracted2ch_Cfpvfpvt)
-
-assert(2 == i_Cfpvfpvt.p2)
-assert('b' == ch_Cfpvfpvt.p2)
-
-
-val ch_Cfpvfpvf = new Cfpvfpvf('a', 'b')
-val i_Cfpvfpvf = new Cfpvfpvf(1, 2)
-val Cfpvfpvf(extracted1i_Cfpvfpvf, extracted2i_Cfpvfpvf) = i_Cfpvfpvf
-val Cfpvfpvf(extracted1ch_Cfpvfpvf, extracted2ch_Cfpvfpvf) = ch_Cfpvfpvf
-assert(1 == extracted1i_Cfpvfpvf)
-assert(2 == extracted2i_Cfpvfpvf)
-assert('a' == extracted1ch_Cfpvfpvf)
-assert('b' == extracted2ch_Cfpvfpvf)
-
-
-
-val ch_Cfpvfvt = new Cfpvfvt('a', 'b')
-val i_Cfpvfvt = new Cfpvfvt(1, 2)
-val Cfpvfvt(extracted1i_Cfpvfvt, extracted2i_Cfpvfvt) = i_Cfpvfvt
-val Cfpvfvt(extracted1ch_Cfpvfvt, extracted2ch_Cfpvfvt) = ch_Cfpvfvt
-assert(1 == extracted1i_Cfpvfvt)
-assert(2 == extracted2i_Cfpvfvt)
-assert('a' == extracted1ch_Cfpvfvt)
-assert('b' == extracted2ch_Cfpvfvt)
-
-assert(2 == i_Cfpvfvt.a)
-assert('b' == ch_Cfpvfvt.a)
-assert(2 == i_Cfpvfvt.p2)
-assert('b' == ch_Cfpvfvt.p2)
-
-
-val ch_Cfpvfvf = new Cfpvfvf('a', 'b')
-val i_Cfpvfvf = new Cfpvfvf(1, 2)
-val Cfpvfvf(extracted1i_Cfpvfvf, extracted2i_Cfpvfvf) = i_Cfpvfvf
-val Cfpvfvf(extracted1ch_Cfpvfvf, extracted2ch_Cfpvfvf) = ch_Cfpvfvf
-assert(1 == extracted1i_Cfpvfvf)
-assert(2 == extracted2i_Cfpvfvf)
-assert('a' == extracted1ch_Cfpvfvf)
-assert('b' == extracted2ch_Cfpvfvf)
-
-assert(2 == i_Cfpvfvf.a)
-assert('b' == ch_Cfpvfvf.a)
-
-
-val ch_Cfpvfnt = new Cfpvfnt('a', 'b')
-val i_Cfpvfnt = new Cfpvfnt(1, 2)
-val Cfpvfnt(extracted1i_Cfpvfnt, extracted2i_Cfpvfnt) = i_Cfpvfnt
-val Cfpvfnt(extracted1ch_Cfpvfnt, extracted2ch_Cfpvfnt) = ch_Cfpvfnt
-assert(1 == extracted1i_Cfpvfnt)
-assert(2 == extracted2i_Cfpvfnt)
-assert('a' == extracted1ch_Cfpvfnt)
-assert('b' == extracted2ch_Cfpvfnt)
-
-assert(2 == i_Cfpvfnt.a)
-assert('b' == ch_Cfpvfnt.a)
-assert(2 == i_Cfpvfnt.p2)
-assert('b' == ch_Cfpvfnt.p2)
-
-
-val ch_Cfpvfnf = new Cfpvfnf('a', 'b')
-val i_Cfpvfnf = new Cfpvfnf(1, 2)
-val Cfpvfnf(extracted1i_Cfpvfnf, extracted2i_Cfpvfnf) = i_Cfpvfnf
-val Cfpvfnf(extracted1ch_Cfpvfnf, extracted2ch_Cfpvfnf) = ch_Cfpvfnf
-assert(1 == extracted1i_Cfpvfnf)
-assert(2 == extracted2i_Cfpvfnf)
-assert('a' == extracted1ch_Cfpvfnf)
-assert('b' == extracted2ch_Cfpvfnf)
-
-assert(2 == i_Cfpvfnf.a)
-assert('b' == ch_Cfpvfnf.a)
-
-
-val ch_Cfvtpvt = new Cfvtpvt('a', 'b')
-val i_Cfvtpvt = new Cfvtpvt(1, 2)
-val Cfvtpvt(extracted1i_Cfvtpvt, extracted2i_Cfvtpvt) = i_Cfvtpvt
-val Cfvtpvt(extracted1ch_Cfvtpvt, extracted2ch_Cfvtpvt) = ch_Cfvtpvt
-assert(1 == extracted1i_Cfvtpvt)
-assert(2 == extracted2i_Cfvtpvt)
-assert('a' == extracted1ch_Cfvtpvt)
-assert('b' == extracted2ch_Cfvtpvt)
-
-assert(1 == i_Cfvtpvt.`a b`)
-assert('a' == ch_Cfvtpvt.`a b`)
-assert(1 == i_Cfvtpvt.p1)
-assert(2 == i_Cfvtpvt.p2)
-assert('a' == ch_Cfvtpvt.p1)
-assert('b' == ch_Cfvtpvt.p2)
-
-
-val ch_Cfvtpvf = new Cfvtpvf('a', 'b')
-val i_Cfvtpvf = new Cfvtpvf(1, 2)
-val Cfvtpvf(extracted1i_Cfvtpvf, extracted2i_Cfvtpvf) = i_Cfvtpvf
-val Cfvtpvf(extracted1ch_Cfvtpvf, extracted2ch_Cfvtpvf) = ch_Cfvtpvf
-assert(1 == extracted1i_Cfvtpvf)
-assert(2 == extracted2i_Cfvtpvf)
-assert('a' == extracted1ch_Cfvtpvf)
-assert('b' == extracted2ch_Cfvtpvf)
-
-assert(1 == i_Cfvtpvf.`a b`)
-assert('a' == ch_Cfvtpvf.`a b`)
-assert(1 == i_Cfvtpvf.p1)
-assert('a' == ch_Cfvtpvf.p1)
-
-
-val ch_Cfvtvt = new Cfvtvt('a', 'b')
-val i_Cfvtvt = new Cfvtvt(1, 2)
-val Cfvtvt(extracted1i_Cfvtvt, extracted2i_Cfvtvt) = i_Cfvtvt
-val Cfvtvt(extracted1ch_Cfvtvt, extracted2ch_Cfvtvt) = ch_Cfvtvt
-assert(1 == extracted1i_Cfvtvt)
-assert(2 == extracted2i_Cfvtvt)
-assert('a' == extracted1ch_Cfvtvt)
-assert('b' == extracted2ch_Cfvtvt)
-
-assert(1 == i_Cfvtvt.`a b`)
-assert(2 == i_Cfvtvt.a)
-assert('a' == ch_Cfvtvt.`a b`)
-assert('b' == ch_Cfvtvt.a)
-assert(1 == i_Cfvtvt.p1)
-assert(2 == i_Cfvtvt.p2)
-assert('a' == ch_Cfvtvt.p1)
-assert('b' == ch_Cfvtvt.p2)
-
-
-val ch_Cfvtvf = new Cfvtvf('a', 'b')
-val i_Cfvtvf = new Cfvtvf(1, 2)
-val Cfvtvf(extracted1i_Cfvtvf, extracted2i_Cfvtvf) = i_Cfvtvf
-val Cfvtvf(extracted1ch_Cfvtvf, extracted2ch_Cfvtvf) = ch_Cfvtvf
-assert(1 == extracted1i_Cfvtvf)
-assert(2 == extracted2i_Cfvtvf)
-assert('a' == extracted1ch_Cfvtvf)
-assert('b' == extracted2ch_Cfvtvf)
-
-assert(1 == i_Cfvtvf.`a b`)
-assert(2 == i_Cfvtvf.a)
-assert('a' == ch_Cfvtvf.`a b`)
-assert('b' == ch_Cfvtvf.a)
-assert(1 == i_Cfvtvf.p1)
-assert('a' == ch_Cfvtvf.p1)
-
-
-val ch_Cfvtnt = new Cfvtnt('a', 'b')
-val i_Cfvtnt = new Cfvtnt(1, 2)
-val Cfvtnt(extracted1i_Cfvtnt, extracted2i_Cfvtnt) = i_Cfvtnt
-val Cfvtnt(extracted1ch_Cfvtnt, extracted2ch_Cfvtnt) = ch_Cfvtnt
-assert(1 == extracted1i_Cfvtnt)
-assert(2 == extracted2i_Cfvtnt)
-assert('a' == extracted1ch_Cfvtnt)
-assert('b' == extracted2ch_Cfvtnt)
-
-assert(1 == i_Cfvtnt.`a b`)
-assert(2 == i_Cfvtnt.a)
-assert('a' == ch_Cfvtnt.`a b`)
-assert('b' == ch_Cfvtnt.a)
-assert(1 == i_Cfvtnt.p1)
-assert(2 == i_Cfvtnt.p2)
-assert('a' == ch_Cfvtnt.p1)
-assert('b' == ch_Cfvtnt.p2)
-
-
-val ch_Cfvtnf = new Cfvtnf('a', 'b')
-val i_Cfvtnf = new Cfvtnf(1, 2)
-val Cfvtnf(extracted1i_Cfvtnf, extracted2i_Cfvtnf) = i_Cfvtnf
-val Cfvtnf(extracted1ch_Cfvtnf, extracted2ch_Cfvtnf) = ch_Cfvtnf
-assert(1 == extracted1i_Cfvtnf)
-assert(2 == extracted2i_Cfvtnf)
-assert('a' == extracted1ch_Cfvtnf)
-assert('b' == extracted2ch_Cfvtnf)
-
-assert(1 == i_Cfvtnf.`a b`)
-assert(2 == i_Cfvtnf.a)
-assert('a' == ch_Cfvtnf.`a b`)
-assert('b' == ch_Cfvtnf.a)
-assert(1 == i_Cfvtnf.p1)
-assert('a' == ch_Cfvtnf.p1)
-
-
-val ch_Cfvfpvt = new Cfvfpvt('a', 'b')
-val i_Cfvfpvt = new Cfvfpvt(1, 2)
-val Cfvfpvt(extracted1i_Cfvfpvt, extracted2i_Cfvfpvt) = i_Cfvfpvt
-val Cfvfpvt(extracted1ch_Cfvfpvt, extracted2ch_Cfvfpvt) = ch_Cfvfpvt
-assert(1 == extracted1i_Cfvfpvt)
-assert(2 == extracted2i_Cfvfpvt)
-assert('a' == extracted1ch_Cfvfpvt)
-assert('b' == extracted2ch_Cfvfpvt)
-
-assert(1 == i_Cfvfpvt.`a b`)
-assert('a' == ch_Cfvfpvt.`a b`)
-assert(2 == i_Cfvfpvt.p2)
-assert('b' == ch_Cfvfpvt.p2)
-
-
-val ch_Cfvfpvf = new Cfvfpvf('a', 'b')
-val i_Cfvfpvf = new Cfvfpvf(1, 2)
-val Cfvfpvf(extracted1i_Cfvfpvf, extracted2i_Cfvfpvf) = i_Cfvfpvf
-val Cfvfpvf(extracted1ch_Cfvfpvf, extracted2ch_Cfvfpvf) = ch_Cfvfpvf
-assert(1 == extracted1i_Cfvfpvf)
-assert(2 == extracted2i_Cfvfpvf)
-assert('a' == extracted1ch_Cfvfpvf)
-assert('b' == extracted2ch_Cfvfpvf)
-
-assert(1 == i_Cfvfpvf.`a b`)
-assert('a' == ch_Cfvfpvf.`a b`)
-
-
-val ch_Cfvfvt = new Cfvfvt('a', 'b')
-val i_Cfvfvt = new Cfvfvt(1, 2)
-val Cfvfvt(extracted1i_Cfvfvt, extracted2i_Cfvfvt) = i_Cfvfvt
-val Cfvfvt(extracted1ch_Cfvfvt, extracted2ch_Cfvfvt) = ch_Cfvfvt
-assert(1 == extracted1i_Cfvfvt)
-assert(2 == extracted2i_Cfvfvt)
-assert('a' == extracted1ch_Cfvfvt)
-assert('b' == extracted2ch_Cfvfvt)
-
-assert(1 == i_Cfvfvt.`a b`)
-assert(2 == i_Cfvfvt.a)
-assert('a' == ch_Cfvfvt.`a b`)
-assert('b' == ch_Cfvfvt.a)
-assert(2 == i_Cfvfvt.p2)
-assert('b' == ch_Cfvfvt.p2)
-
-
-val ch_Cfvfvf = new Cfvfvf('a', 'b')
-val i_Cfvfvf = new Cfvfvf(1, 2)
-val Cfvfvf(extracted1i_Cfvfvf, extracted2i_Cfvfvf) = i_Cfvfvf
-val Cfvfvf(extracted1ch_Cfvfvf, extracted2ch_Cfvfvf) = ch_Cfvfvf
-assert(1 == extracted1i_Cfvfvf)
-assert(2 == extracted2i_Cfvfvf)
-assert('a' == extracted1ch_Cfvfvf)
-assert('b' == extracted2ch_Cfvfvf)
-
-assert(1 == i_Cfvfvf.`a b`)
-assert(2 == i_Cfvfvf.a)
-assert('a' == ch_Cfvfvf.`a b`)
-assert('b' == ch_Cfvfvf.a)
-
-
-val ch_Cfvfnt = new Cfvfnt('a', 'b')
-val i_Cfvfnt = new Cfvfnt(1, 2)
-val Cfvfnt(extracted1i_Cfvfnt, extracted2i_Cfvfnt) = i_Cfvfnt
-val Cfvfnt(extracted1ch_Cfvfnt, extracted2ch_Cfvfnt) = ch_Cfvfnt
-assert(1 == extracted1i_Cfvfnt)
-assert(2 == extracted2i_Cfvfnt)
-assert('a' == extracted1ch_Cfvfnt)
-assert('b' == extracted2ch_Cfvfnt)
-
-assert(1 == i_Cfvfnt.`a b`)
-assert(2 == i_Cfvfnt.a)
-assert('a' == ch_Cfvfnt.`a b`)
-assert('b' == ch_Cfvfnt.a)
-assert(2 == i_Cfvfnt.p2)
-assert('b' == ch_Cfvfnt.p2)
-
-
-val ch_Cfvfnf = new Cfvfnf('a', 'b')
-val i_Cfvfnf = new Cfvfnf(1, 2)
-val Cfvfnf(extracted1i_Cfvfnf, extracted2i_Cfvfnf) = i_Cfvfnf
-val Cfvfnf(extracted1ch_Cfvfnf, extracted2ch_Cfvfnf) = ch_Cfvfnf
-assert(1 == extracted1i_Cfvfnf)
-assert(2 == extracted2i_Cfvfnf)
-assert('a' == extracted1ch_Cfvfnf)
-assert('b' == extracted2ch_Cfvfnf)
-
-assert(1 == i_Cfvfnf.`a b`)
-assert(2 == i_Cfvfnf.a)
-assert('a' == ch_Cfvfnf.`a b`)
-assert('b' == ch_Cfvfnf.a)
-
-
-val ch_Cfntpvt = new Cfntpvt('a', 'b')
-val i_Cfntpvt = new Cfntpvt(1, 2)
-val Cfntpvt(extracted1i_Cfntpvt, extracted2i_Cfntpvt) = i_Cfntpvt
-val Cfntpvt(extracted1ch_Cfntpvt, extracted2ch_Cfntpvt) = ch_Cfntpvt
-assert(1 == extracted1i_Cfntpvt)
-assert(2 == extracted2i_Cfntpvt)
-assert('a' == extracted1ch_Cfntpvt)
-assert('b' == extracted2ch_Cfntpvt)
-
-assert(1 == i_Cfntpvt.`a b`)
-assert('a' == ch_Cfntpvt.`a b`)
-assert(1 == i_Cfntpvt.p1)
-assert(2 == i_Cfntpvt.p2)
-assert('a' == ch_Cfntpvt.p1)
-assert('b' == ch_Cfntpvt.p2)
-
-
-val ch_Cfntpvf = new Cfntpvf('a', 'b')
-val i_Cfntpvf = new Cfntpvf(1, 2)
-val Cfntpvf(extracted1i_Cfntpvf, extracted2i_Cfntpvf) = i_Cfntpvf
-val Cfntpvf(extracted1ch_Cfntpvf, extracted2ch_Cfntpvf) = ch_Cfntpvf
-assert(1 == extracted1i_Cfntpvf)
-assert(2 == extracted2i_Cfntpvf)
-assert('a' == extracted1ch_Cfntpvf)
-assert('b' == extracted2ch_Cfntpvf)
-
-assert(1 == i_Cfntpvf.`a b`)
-assert('a' == ch_Cfntpvf.`a b`)
-assert(1 == i_Cfntpvf.p1)
-assert('a' == ch_Cfntpvf.p1)
-
-
-val ch_Cfntvt = new Cfntvt('a', 'b')
-val i_Cfntvt = new Cfntvt(1, 2)
-val Cfntvt(extracted1i_Cfntvt, extracted2i_Cfntvt) = i_Cfntvt
-val Cfntvt(extracted1ch_Cfntvt, extracted2ch_Cfntvt) = ch_Cfntvt
-assert(1 == extracted1i_Cfntvt)
-assert(2 == extracted2i_Cfntvt)
-assert('a' == extracted1ch_Cfntvt)
-assert('b' == extracted2ch_Cfntvt)
-
-assert(1 == i_Cfntvt.`a b`)
-assert(2 == i_Cfntvt.a)
-assert('a' == ch_Cfntvt.`a b`)
-assert('b' == ch_Cfntvt.a)
-assert(1 == i_Cfntvt.p1)
-assert(2 == i_Cfntvt.p2)
-assert('a' == ch_Cfntvt.p1)
-assert('b' == ch_Cfntvt.p2)
-
-
-val ch_Cfntvf = new Cfntvf('a', 'b')
-val i_Cfntvf = new Cfntvf(1, 2)
-val Cfntvf(extracted1i_Cfntvf, extracted2i_Cfntvf) = i_Cfntvf
-val Cfntvf(extracted1ch_Cfntvf, extracted2ch_Cfntvf) = ch_Cfntvf
-assert(1 == extracted1i_Cfntvf)
-assert(2 == extracted2i_Cfntvf)
-assert('a' == extracted1ch_Cfntvf)
-assert('b' == extracted2ch_Cfntvf)
-
-assert(1 == i_Cfntvf.`a b`)
-assert(2 == i_Cfntvf.a)
-assert('a' == ch_Cfntvf.`a b`)
-assert('b' == ch_Cfntvf.a)
-assert(1 == i_Cfntvf.p1)
-assert('a' == ch_Cfntvf.p1)
-
-
-val ch_Cfntnt = new Cfntnt('a', 'b')
-val i_Cfntnt = new Cfntnt(1, 2)
-val Cfntnt(extracted1i_Cfntnt, extracted2i_Cfntnt) = i_Cfntnt
-val Cfntnt(extracted1ch_Cfntnt, extracted2ch_Cfntnt) = ch_Cfntnt
-assert(1 == extracted1i_Cfntnt)
-assert(2 == extracted2i_Cfntnt)
-assert('a' == extracted1ch_Cfntnt)
-assert('b' == extracted2ch_Cfntnt)
-
-assert(1 == i_Cfntnt.`a b`)
-assert(2 == i_Cfntnt.a)
-assert('a' == ch_Cfntnt.`a b`)
-assert('b' == ch_Cfntnt.a)
-assert(1 == i_Cfntnt.p1)
-assert(2 == i_Cfntnt.p2)
-assert('a' == ch_Cfntnt.p1)
-assert('b' == ch_Cfntnt.p2)
-
-
-val ch_Cfntnf = new Cfntnf('a', 'b')
-val i_Cfntnf = new Cfntnf(1, 2)
-val Cfntnf(extracted1i_Cfntnf, extracted2i_Cfntnf) = i_Cfntnf
-val Cfntnf(extracted1ch_Cfntnf, extracted2ch_Cfntnf) = ch_Cfntnf
-assert(1 == extracted1i_Cfntnf)
-assert(2 == extracted2i_Cfntnf)
-assert('a' == extracted1ch_Cfntnf)
-assert('b' == extracted2ch_Cfntnf)
-
-assert(1 == i_Cfntnf.`a b`)
-assert(2 == i_Cfntnf.a)
-assert('a' == ch_Cfntnf.`a b`)
-assert('b' == ch_Cfntnf.a)
-assert(1 == i_Cfntnf.p1)
-assert('a' == ch_Cfntnf.p1)
-
-
-val ch_Cfnfpvt = new Cfnfpvt('a', 'b')
-val i_Cfnfpvt = new Cfnfpvt(1, 2)
-val Cfnfpvt(extracted1i_Cfnfpvt, extracted2i_Cfnfpvt) = i_Cfnfpvt
-val Cfnfpvt(extracted1ch_Cfnfpvt, extracted2ch_Cfnfpvt) = ch_Cfnfpvt
-assert(1 == extracted1i_Cfnfpvt)
-assert(2 == extracted2i_Cfnfpvt)
-assert('a' == extracted1ch_Cfnfpvt)
-assert('b' == extracted2ch_Cfnfpvt)
-
-assert(1 == i_Cfnfpvt.`a b`)
-assert('a' == ch_Cfnfpvt.`a b`)
-assert(2 == i_Cfnfpvt.p2)
-assert('b' == ch_Cfnfpvt.p2)
-
-
-val ch_Cfnfpvf = new Cfnfpvf('a', 'b')
-val i_Cfnfpvf = new Cfnfpvf(1, 2)
-val Cfnfpvf(extracted1i_Cfnfpvf, extracted2i_Cfnfpvf) = i_Cfnfpvf
-val Cfnfpvf(extracted1ch_Cfnfpvf, extracted2ch_Cfnfpvf) = ch_Cfnfpvf
-assert(1 == extracted1i_Cfnfpvf)
-assert(2 == extracted2i_Cfnfpvf)
-assert('a' == extracted1ch_Cfnfpvf)
-assert('b' == extracted2ch_Cfnfpvf)
-
-assert(1 == i_Cfnfpvf.`a b`)
-assert('a' == ch_Cfnfpvf.`a b`)
-
-
-val ch_Cfnfvt = new Cfnfvt('a', 'b')
-val i_Cfnfvt = new Cfnfvt(1, 2)
-val Cfnfvt(extracted1i_Cfnfvt, extracted2i_Cfnfvt) = i_Cfnfvt
-val Cfnfvt(extracted1ch_Cfnfvt, extracted2ch_Cfnfvt) = ch_Cfnfvt
-assert(1 == extracted1i_Cfnfvt)
-assert(2 == extracted2i_Cfnfvt)
-assert('a' == extracted1ch_Cfnfvt)
-assert('b' == extracted2ch_Cfnfvt)
-
-assert(1 == i_Cfnfvt.`a b`)
-assert(2 == i_Cfnfvt.a)
-assert('a' == ch_Cfnfvt.`a b`)
-assert('b' == ch_Cfnfvt.a)
-assert(2 == i_Cfnfvt.p2)
-assert('b' == ch_Cfnfvt.p2)
-
-
-val ch_Cfnfvf = new Cfnfvf('a', 'b')
-val i_Cfnfvf = new Cfnfvf(1, 2)
-val Cfnfvf(extracted1i_Cfnfvf, extracted2i_Cfnfvf) = i_Cfnfvf
-val Cfnfvf(extracted1ch_Cfnfvf, extracted2ch_Cfnfvf) = ch_Cfnfvf
-assert(1 == extracted1i_Cfnfvf)
-assert(2 == extracted2i_Cfnfvf)
-assert('a' == extracted1ch_Cfnfvf)
-assert('b' == extracted2ch_Cfnfvf)
-
-assert(1 == i_Cfnfvf.`a b`)
-assert(2 == i_Cfnfvf.a)
-assert('a' == ch_Cfnfvf.`a b`)
-assert('b' == ch_Cfnfvf.a)
-
-
-val ch_Cfnfnt = new Cfnfnt('a', 'b')
-val i_Cfnfnt = new Cfnfnt(1, 2)
-val Cfnfnt(extracted1i_Cfnfnt, extracted2i_Cfnfnt) = i_Cfnfnt
-val Cfnfnt(extracted1ch_Cfnfnt, extracted2ch_Cfnfnt) = ch_Cfnfnt
-assert(1 == extracted1i_Cfnfnt)
-assert(2 == extracted2i_Cfnfnt)
-assert('a' == extracted1ch_Cfnfnt)
-assert('b' == extracted2ch_Cfnfnt)
-
-assert(1 == i_Cfnfnt.`a b`)
-assert(2 == i_Cfnfnt.a)
-assert('a' == ch_Cfnfnt.`a b`)
-assert('b' == ch_Cfnfnt.a)
-assert(2 == i_Cfnfnt.p2)
-assert('b' == ch_Cfnfnt.p2)
-
-
-val ch_Cfnfnf = new Cfnfnf('a', 'b')
-val i_Cfnfnf = new Cfnfnf(1, 2)
-val Cfnfnf(extracted1i_Cfnfnf, extracted2i_Cfnfnf) = i_Cfnfnf
-val Cfnfnf(extracted1ch_Cfnfnf, extracted2ch_Cfnfnf) = ch_Cfnfnf
-assert(1 == extracted1i_Cfnfnf)
-assert(2 == extracted2i_Cfnfnf)
-assert('a' == extracted1ch_Cfnfnf)
-assert('b' == extracted2ch_Cfnfnf)
-
-assert(1 == i_Cfnfnf.`a b`)
-assert(2 == i_Cfnfnf.a)
-assert('a' == ch_Cfnfnf.`a b`)
-assert('b' == ch_Cfnfnf.a)
-
-
-val ch_Rtpvtpvt = new Rtpvtpvt('a', 'b')
-val i_Rtpvtpvt = new Rtpvtpvt(1, 2)
-assert(1 == i_Rtpvtpvt.p1)
-assert(2 == i_Rtpvtpvt.p2)
-assert('a' == ch_Rtpvtpvt.p1)
-assert('b' == ch_Rtpvtpvt.p2)
-
-
-val ch_Rtpvtpvf = new Rtpvtpvf('a', 'b')
-val i_Rtpvtpvf = new Rtpvtpvf(1, 2)
-assert(1 == i_Rtpvtpvf.p1)
-assert('a' == ch_Rtpvtpvf.p1)
-
-
-val ch_Rtpvtvt = new Rtpvtvt('a', 'b')
-val i_Rtpvtvt = new Rtpvtvt(1, 2)
-assert(2 == i_Rtpvtvt.a)
-assert('b' == ch_Rtpvtvt.a)
-assert(1 == i_Rtpvtvt.p1)
-assert(2 == i_Rtpvtvt.p2)
-assert('a' == ch_Rtpvtvt.p1)
-assert('b' == ch_Rtpvtvt.p2)
-
-
-val ch_Rtpvtvf = new Rtpvtvf('a', 'b')
-val i_Rtpvtvf = new Rtpvtvf(1, 2)
-assert(2 == i_Rtpvtvf.a)
-assert('b' == ch_Rtpvtvf.a)
-assert(1 == i_Rtpvtvf.p1)
-assert('a' == ch_Rtpvtvf.p1)
-
-
-val ch_Rtpvtnt = new Rtpvtnt('a', 'b')
-val i_Rtpvtnt = new Rtpvtnt(1, 2)
-assert(1 == i_Rtpvtnt.p1)
-assert(2 == i_Rtpvtnt.p2)
-assert('a' == ch_Rtpvtnt.p1)
-assert('b' == ch_Rtpvtnt.p2)
-
-
-val ch_Rtpvtnf = new Rtpvtnf('a', 'b')
-val i_Rtpvtnf = new Rtpvtnf(1, 2)
-assert(1 == i_Rtpvtnf.p1)
-assert('a' == ch_Rtpvtnf.p1)
-
-
-val ch_Rtpvfpvt = new Rtpvfpvt('a', 'b')
-val i_Rtpvfpvt = new Rtpvfpvt(1, 2)
-assert(2 == i_Rtpvfpvt.p2)
-assert('b' == ch_Rtpvfpvt.p2)
-
-
-val ch_Rtpvfvt = new Rtpvfvt('a', 'b')
-val i_Rtpvfvt = new Rtpvfvt(1, 2)
-assert(2 == i_Rtpvfvt.a)
-assert('b' == ch_Rtpvfvt.a)
-assert(2 == i_Rtpvfvt.p2)
-assert('b' == ch_Rtpvfvt.p2)
-
-
-val ch_Rtpvfnt = new Rtpvfnt('a', 'b')
-val i_Rtpvfnt = new Rtpvfnt(1, 2)
-assert(2 == i_Rtpvfnt.p2)
-assert('b' == ch_Rtpvfnt.p2)
-
-
-val ch_Rtvtpvt = new Rtvtpvt('a', 'b')
-val i_Rtvtpvt = new Rtvtpvt(1, 2)
-assert(1 == i_Rtvtpvt.`a b`)
-assert('a' == ch_Rtvtpvt.`a b`)
-assert(1 == i_Rtvtpvt.p1)
-assert(2 == i_Rtvtpvt.p2)
-assert('a' == ch_Rtvtpvt.p1)
-assert('b' == ch_Rtvtpvt.p2)
-
-
-val ch_Rtvtpvf = new Rtvtpvf('a', 'b')
-val i_Rtvtpvf = new Rtvtpvf(1, 2)
-assert(1 == i_Rtvtpvf.`a b`)
-assert('a' == ch_Rtvtpvf.`a b`)
-assert(1 == i_Rtvtpvf.p1)
-assert('a' == ch_Rtvtpvf.p1)
-
-
-val ch_Rtvtvt = new Rtvtvt('a', 'b')
-val i_Rtvtvt = new Rtvtvt(1, 2)
-assert(1 == i_Rtvtvt.`a b`)
-assert(2 == i_Rtvtvt.a)
-assert('a' == ch_Rtvtvt.`a b`)
-assert('b' == ch_Rtvtvt.a)
-assert(1 == i_Rtvtvt.p1)
-assert(2 == i_Rtvtvt.p2)
-assert('a' == ch_Rtvtvt.p1)
-assert('b' == ch_Rtvtvt.p2)
-
+val ch_Cpvt_pvt = new Cpvt_pvt('a', 'b')
+val i_Cpvt_pvt = new Cpvt_pvt(1, 2)
+val Cpvt_pvt(extracted1i_Cpvt_pvt, extracted2i_Cpvt_pvt) = i_Cpvt_pvt
+val Cpvt_pvt(extracted1ch_Cpvt_pvt, extracted2ch_Cpvt_pvt) = ch_Cpvt_pvt
+assert(1 == extracted1i_Cpvt_pvt)
+assert(2 == extracted2i_Cpvt_pvt)
+assert('a' == extracted1ch_Cpvt_pvt)
+assert('b' == extracted2ch_Cpvt_pvt)
+
+assert(1 == i_Cpvt_pvt.p1)
+assert(2 == i_Cpvt_pvt.p2)
+assert('a' == ch_Cpvt_pvt.p1)
+assert('b' == ch_Cpvt_pvt.p2)
+
+
+val ch_Cpvt_pvf = new Cpvt_pvf('a', 'b')
+val i_Cpvt_pvf = new Cpvt_pvf(1, 2)
+val Cpvt_pvf(extracted1i_Cpvt_pvf, extracted2i_Cpvt_pvf) = i_Cpvt_pvf
+val Cpvt_pvf(extracted1ch_Cpvt_pvf, extracted2ch_Cpvt_pvf) = ch_Cpvt_pvf
+assert(1 == extracted1i_Cpvt_pvf)
+assert(2 == extracted2i_Cpvt_pvf)
+assert('a' == extracted1ch_Cpvt_pvf)
+assert('b' == extracted2ch_Cpvt_pvf)
+
+assert(1 == i_Cpvt_pvf.p1)
+assert('a' == ch_Cpvt_pvf.p1)
+
+
+val ch_Cpvt_vt = new Cpvt_vt('a', 'b')
+val i_Cpvt_vt = new Cpvt_vt(1, 2)
+val Cpvt_vt(extracted1i_Cpvt_vt, extracted2i_Cpvt_vt) = i_Cpvt_vt
+val Cpvt_vt(extracted1ch_Cpvt_vt, extracted2ch_Cpvt_vt) = ch_Cpvt_vt
+assert(1 == extracted1i_Cpvt_vt)
+assert(2 == extracted2i_Cpvt_vt)
+assert('a' == extracted1ch_Cpvt_vt)
+assert('b' == extracted2ch_Cpvt_vt)
+
+assert(2 == i_Cpvt_vt.a)
+assert('b' == ch_Cpvt_vt.a)
+assert(1 == i_Cpvt_vt.p1)
+assert(2 == i_Cpvt_vt.p2)
+assert('a' == ch_Cpvt_vt.p1)
+assert('b' == ch_Cpvt_vt.p2)
+
+
+val ch_Cpvt_vf = new Cpvt_vf('a', 'b')
+val i_Cpvt_vf = new Cpvt_vf(1, 2)
+val Cpvt_vf(extracted1i_Cpvt_vf, extracted2i_Cpvt_vf) = i_Cpvt_vf
+val Cpvt_vf(extracted1ch_Cpvt_vf, extracted2ch_Cpvt_vf) = ch_Cpvt_vf
+assert(1 == extracted1i_Cpvt_vf)
+assert(2 == extracted2i_Cpvt_vf)
+assert('a' == extracted1ch_Cpvt_vf)
+assert('b' == extracted2ch_Cpvt_vf)
+
+assert(2 == i_Cpvt_vf.a)
+assert('b' == ch_Cpvt_vf.a)
+assert(1 == i_Cpvt_vf.p1)
+assert('a' == ch_Cpvt_vf.p1)
+
+
+val ch_Cpvt_nt = new Cpvt_nt('a', 'b')
+val i_Cpvt_nt = new Cpvt_nt(1, 2)
+val Cpvt_nt(extracted1i_Cpvt_nt, extracted2i_Cpvt_nt) = i_Cpvt_nt
+val Cpvt_nt(extracted1ch_Cpvt_nt, extracted2ch_Cpvt_nt) = ch_Cpvt_nt
+assert(1 == extracted1i_Cpvt_nt)
+assert(2 == extracted2i_Cpvt_nt)
+assert('a' == extracted1ch_Cpvt_nt)
+assert('b' == extracted2ch_Cpvt_nt)
+
+assert(2 == i_Cpvt_nt.a)
+assert('b' == ch_Cpvt_nt.a)
+assert(1 == i_Cpvt_nt.p1)
+assert(2 == i_Cpvt_nt.p2)
+assert('a' == ch_Cpvt_nt.p1)
+assert('b' == ch_Cpvt_nt.p2)
+
+
+val ch_Cpvt_nf = new Cpvt_nf('a', 'b')
+val i_Cpvt_nf = new Cpvt_nf(1, 2)
+val Cpvt_nf(extracted1i_Cpvt_nf, extracted2i_Cpvt_nf) = i_Cpvt_nf
+val Cpvt_nf(extracted1ch_Cpvt_nf, extracted2ch_Cpvt_nf) = ch_Cpvt_nf
+assert(1 == extracted1i_Cpvt_nf)
+assert(2 == extracted2i_Cpvt_nf)
+assert('a' == extracted1ch_Cpvt_nf)
+assert('b' == extracted2ch_Cpvt_nf)
+
+assert(2 == i_Cpvt_nf.a)
+assert('b' == ch_Cpvt_nf.a)
+assert(1 == i_Cpvt_nf.p1)
+assert('a' == ch_Cpvt_nf.p1)
+
+
+val ch_Cpvf_pvt = new Cpvf_pvt('a', 'b')
+val i_Cpvf_pvt = new Cpvf_pvt(1, 2)
+val Cpvf_pvt(extracted1i_Cpvf_pvt, extracted2i_Cpvf_pvt) = i_Cpvf_pvt
+val Cpvf_pvt(extracted1ch_Cpvf_pvt, extracted2ch_Cpvf_pvt) = ch_Cpvf_pvt
+assert(1 == extracted1i_Cpvf_pvt)
+assert(2 == extracted2i_Cpvf_pvt)
+assert('a' == extracted1ch_Cpvf_pvt)
+assert('b' == extracted2ch_Cpvf_pvt)
+
+assert(2 == i_Cpvf_pvt.p2)
+assert('b' == ch_Cpvf_pvt.p2)
+
+
+val ch_Cpvf_pvf = new Cpvf_pvf('a', 'b')
+val i_Cpvf_pvf = new Cpvf_pvf(1, 2)
+val Cpvf_pvf(extracted1i_Cpvf_pvf, extracted2i_Cpvf_pvf) = i_Cpvf_pvf
+val Cpvf_pvf(extracted1ch_Cpvf_pvf, extracted2ch_Cpvf_pvf) = ch_Cpvf_pvf
+assert(1 == extracted1i_Cpvf_pvf)
+assert(2 == extracted2i_Cpvf_pvf)
+assert('a' == extracted1ch_Cpvf_pvf)
+assert('b' == extracted2ch_Cpvf_pvf)
+
+
+
+val ch_Cpvf_vt = new Cpvf_vt('a', 'b')
+val i_Cpvf_vt = new Cpvf_vt(1, 2)
+val Cpvf_vt(extracted1i_Cpvf_vt, extracted2i_Cpvf_vt) = i_Cpvf_vt
+val Cpvf_vt(extracted1ch_Cpvf_vt, extracted2ch_Cpvf_vt) = ch_Cpvf_vt
+assert(1 == extracted1i_Cpvf_vt)
+assert(2 == extracted2i_Cpvf_vt)
+assert('a' == extracted1ch_Cpvf_vt)
+assert('b' == extracted2ch_Cpvf_vt)
+
+assert(2 == i_Cpvf_vt.a)
+assert('b' == ch_Cpvf_vt.a)
+assert(2 == i_Cpvf_vt.p2)
+assert('b' == ch_Cpvf_vt.p2)
+
+
+val ch_Cpvf_vf = new Cpvf_vf('a', 'b')
+val i_Cpvf_vf = new Cpvf_vf(1, 2)
+val Cpvf_vf(extracted1i_Cpvf_vf, extracted2i_Cpvf_vf) = i_Cpvf_vf
+val Cpvf_vf(extracted1ch_Cpvf_vf, extracted2ch_Cpvf_vf) = ch_Cpvf_vf
+assert(1 == extracted1i_Cpvf_vf)
+assert(2 == extracted2i_Cpvf_vf)
+assert('a' == extracted1ch_Cpvf_vf)
+assert('b' == extracted2ch_Cpvf_vf)
+
+assert(2 == i_Cpvf_vf.a)
+assert('b' == ch_Cpvf_vf.a)
+
+
+val ch_Cpvf_nt = new Cpvf_nt('a', 'b')
+val i_Cpvf_nt = new Cpvf_nt(1, 2)
+val Cpvf_nt(extracted1i_Cpvf_nt, extracted2i_Cpvf_nt) = i_Cpvf_nt
+val Cpvf_nt(extracted1ch_Cpvf_nt, extracted2ch_Cpvf_nt) = ch_Cpvf_nt
+assert(1 == extracted1i_Cpvf_nt)
+assert(2 == extracted2i_Cpvf_nt)
+assert('a' == extracted1ch_Cpvf_nt)
+assert('b' == extracted2ch_Cpvf_nt)
+
+assert(2 == i_Cpvf_nt.a)
+assert('b' == ch_Cpvf_nt.a)
+assert(2 == i_Cpvf_nt.p2)
+assert('b' == ch_Cpvf_nt.p2)
+
+
+val ch_Cpvf_nf = new Cpvf_nf('a', 'b')
+val i_Cpvf_nf = new Cpvf_nf(1, 2)
+val Cpvf_nf(extracted1i_Cpvf_nf, extracted2i_Cpvf_nf) = i_Cpvf_nf
+val Cpvf_nf(extracted1ch_Cpvf_nf, extracted2ch_Cpvf_nf) = ch_Cpvf_nf
+assert(1 == extracted1i_Cpvf_nf)
+assert(2 == extracted2i_Cpvf_nf)
+assert('a' == extracted1ch_Cpvf_nf)
+assert('b' == extracted2ch_Cpvf_nf)
+
+assert(2 == i_Cpvf_nf.a)
+assert('b' == ch_Cpvf_nf.a)
+
+
+val ch_Cvt_pvt = new Cvt_pvt('a', 'b')
+val i_Cvt_pvt = new Cvt_pvt(1, 2)
+val Cvt_pvt(extracted1i_Cvt_pvt, extracted2i_Cvt_pvt) = i_Cvt_pvt
+val Cvt_pvt(extracted1ch_Cvt_pvt, extracted2ch_Cvt_pvt) = ch_Cvt_pvt
+assert(1 == extracted1i_Cvt_pvt)
+assert(2 == extracted2i_Cvt_pvt)
+assert('a' == extracted1ch_Cvt_pvt)
+assert('b' == extracted2ch_Cvt_pvt)
+
+assert(1 == i_Cvt_pvt.`a b`)
+assert('a' == ch_Cvt_pvt.`a b`)
+assert(1 == i_Cvt_pvt.p1)
+assert(2 == i_Cvt_pvt.p2)
+assert('a' == ch_Cvt_pvt.p1)
+assert('b' == ch_Cvt_pvt.p2)
+
+
+val ch_Cvt_pvf = new Cvt_pvf('a', 'b')
+val i_Cvt_pvf = new Cvt_pvf(1, 2)
+val Cvt_pvf(extracted1i_Cvt_pvf, extracted2i_Cvt_pvf) = i_Cvt_pvf
+val Cvt_pvf(extracted1ch_Cvt_pvf, extracted2ch_Cvt_pvf) = ch_Cvt_pvf
+assert(1 == extracted1i_Cvt_pvf)
+assert(2 == extracted2i_Cvt_pvf)
+assert('a' == extracted1ch_Cvt_pvf)
+assert('b' == extracted2ch_Cvt_pvf)
+
+assert(1 == i_Cvt_pvf.`a b`)
+assert('a' == ch_Cvt_pvf.`a b`)
+assert(1 == i_Cvt_pvf.p1)
+assert('a' == ch_Cvt_pvf.p1)
+
+
+val ch_Cvt_vt = new Cvt_vt('a', 'b')
+val i_Cvt_vt = new Cvt_vt(1, 2)
+val Cvt_vt(extracted1i_Cvt_vt, extracted2i_Cvt_vt) = i_Cvt_vt
+val Cvt_vt(extracted1ch_Cvt_vt, extracted2ch_Cvt_vt) = ch_Cvt_vt
+assert(1 == extracted1i_Cvt_vt)
+assert(2 == extracted2i_Cvt_vt)
+assert('a' == extracted1ch_Cvt_vt)
+assert('b' == extracted2ch_Cvt_vt)
+
+assert(1 == i_Cvt_vt.`a b`)
+assert(2 == i_Cvt_vt.a)
+assert('a' == ch_Cvt_vt.`a b`)
+assert('b' == ch_Cvt_vt.a)
+assert(1 == i_Cvt_vt.p1)
+assert(2 == i_Cvt_vt.p2)
+assert('a' == ch_Cvt_vt.p1)
+assert('b' == ch_Cvt_vt.p2)
+
+
+val ch_Cvt_vf = new Cvt_vf('a', 'b')
+val i_Cvt_vf = new Cvt_vf(1, 2)
+val Cvt_vf(extracted1i_Cvt_vf, extracted2i_Cvt_vf) = i_Cvt_vf
+val Cvt_vf(extracted1ch_Cvt_vf, extracted2ch_Cvt_vf) = ch_Cvt_vf
+assert(1 == extracted1i_Cvt_vf)
+assert(2 == extracted2i_Cvt_vf)
+assert('a' == extracted1ch_Cvt_vf)
+assert('b' == extracted2ch_Cvt_vf)
+
+assert(1 == i_Cvt_vf.`a b`)
+assert(2 == i_Cvt_vf.a)
+assert('a' == ch_Cvt_vf.`a b`)
+assert('b' == ch_Cvt_vf.a)
+assert(1 == i_Cvt_vf.p1)
+assert('a' == ch_Cvt_vf.p1)
+
+
+val ch_Cvt_nt = new Cvt_nt('a', 'b')
+val i_Cvt_nt = new Cvt_nt(1, 2)
+val Cvt_nt(extracted1i_Cvt_nt, extracted2i_Cvt_nt) = i_Cvt_nt
+val Cvt_nt(extracted1ch_Cvt_nt, extracted2ch_Cvt_nt) = ch_Cvt_nt
+assert(1 == extracted1i_Cvt_nt)
+assert(2 == extracted2i_Cvt_nt)
+assert('a' == extracted1ch_Cvt_nt)
+assert('b' == extracted2ch_Cvt_nt)
+
+assert(1 == i_Cvt_nt.`a b`)
+assert(2 == i_Cvt_nt.a)
+assert('a' == ch_Cvt_nt.`a b`)
+assert('b' == ch_Cvt_nt.a)
+assert(1 == i_Cvt_nt.p1)
+assert(2 == i_Cvt_nt.p2)
+assert('a' == ch_Cvt_nt.p1)
+assert('b' == ch_Cvt_nt.p2)
+
+
+val ch_Cvt_nf = new Cvt_nf('a', 'b')
+val i_Cvt_nf = new Cvt_nf(1, 2)
+val Cvt_nf(extracted1i_Cvt_nf, extracted2i_Cvt_nf) = i_Cvt_nf
+val Cvt_nf(extracted1ch_Cvt_nf, extracted2ch_Cvt_nf) = ch_Cvt_nf
+assert(1 == extracted1i_Cvt_nf)
+assert(2 == extracted2i_Cvt_nf)
+assert('a' == extracted1ch_Cvt_nf)
+assert('b' == extracted2ch_Cvt_nf)
+
+assert(1 == i_Cvt_nf.`a b`)
+assert(2 == i_Cvt_nf.a)
+assert('a' == ch_Cvt_nf.`a b`)
+assert('b' == ch_Cvt_nf.a)
+assert(1 == i_Cvt_nf.p1)
+assert('a' == ch_Cvt_nf.p1)
+
+
+val ch_Cvf_pvt = new Cvf_pvt('a', 'b')
+val i_Cvf_pvt = new Cvf_pvt(1, 2)
+val Cvf_pvt(extracted1i_Cvf_pvt, extracted2i_Cvf_pvt) = i_Cvf_pvt
+val Cvf_pvt(extracted1ch_Cvf_pvt, extracted2ch_Cvf_pvt) = ch_Cvf_pvt
+assert(1 == extracted1i_Cvf_pvt)
+assert(2 == extracted2i_Cvf_pvt)
+assert('a' == extracted1ch_Cvf_pvt)
+assert('b' == extracted2ch_Cvf_pvt)
+
+assert(1 == i_Cvf_pvt.`a b`)
+assert('a' == ch_Cvf_pvt.`a b`)
+assert(2 == i_Cvf_pvt.p2)
+assert('b' == ch_Cvf_pvt.p2)
+
+
+val ch_Cvf_pvf = new Cvf_pvf('a', 'b')
+val i_Cvf_pvf = new Cvf_pvf(1, 2)
+val Cvf_pvf(extracted1i_Cvf_pvf, extracted2i_Cvf_pvf) = i_Cvf_pvf
+val Cvf_pvf(extracted1ch_Cvf_pvf, extracted2ch_Cvf_pvf) = ch_Cvf_pvf
+assert(1 == extracted1i_Cvf_pvf)
+assert(2 == extracted2i_Cvf_pvf)
+assert('a' == extracted1ch_Cvf_pvf)
+assert('b' == extracted2ch_Cvf_pvf)
+
+assert(1 == i_Cvf_pvf.`a b`)
+assert('a' == ch_Cvf_pvf.`a b`)
+
+
+val ch_Cvf_vt = new Cvf_vt('a', 'b')
+val i_Cvf_vt = new Cvf_vt(1, 2)
+val Cvf_vt(extracted1i_Cvf_vt, extracted2i_Cvf_vt) = i_Cvf_vt
+val Cvf_vt(extracted1ch_Cvf_vt, extracted2ch_Cvf_vt) = ch_Cvf_vt
+assert(1 == extracted1i_Cvf_vt)
+assert(2 == extracted2i_Cvf_vt)
+assert('a' == extracted1ch_Cvf_vt)
+assert('b' == extracted2ch_Cvf_vt)
+
+assert(1 == i_Cvf_vt.`a b`)
+assert(2 == i_Cvf_vt.a)
+assert('a' == ch_Cvf_vt.`a b`)
+assert('b' == ch_Cvf_vt.a)
+assert(2 == i_Cvf_vt.p2)
+assert('b' == ch_Cvf_vt.p2)
+
+
+val ch_Cvf_vf = new Cvf_vf('a', 'b')
+val i_Cvf_vf = new Cvf_vf(1, 2)
+val Cvf_vf(extracted1i_Cvf_vf, extracted2i_Cvf_vf) = i_Cvf_vf
+val Cvf_vf(extracted1ch_Cvf_vf, extracted2ch_Cvf_vf) = ch_Cvf_vf
+assert(1 == extracted1i_Cvf_vf)
+assert(2 == extracted2i_Cvf_vf)
+assert('a' == extracted1ch_Cvf_vf)
+assert('b' == extracted2ch_Cvf_vf)
+
+assert(1 == i_Cvf_vf.`a b`)
+assert(2 == i_Cvf_vf.a)
+assert('a' == ch_Cvf_vf.`a b`)
+assert('b' == ch_Cvf_vf.a)
+
+
+val ch_Cvf_nt = new Cvf_nt('a', 'b')
+val i_Cvf_nt = new Cvf_nt(1, 2)
+val Cvf_nt(extracted1i_Cvf_nt, extracted2i_Cvf_nt) = i_Cvf_nt
+val Cvf_nt(extracted1ch_Cvf_nt, extracted2ch_Cvf_nt) = ch_Cvf_nt
+assert(1 == extracted1i_Cvf_nt)
+assert(2 == extracted2i_Cvf_nt)
+assert('a' == extracted1ch_Cvf_nt)
+assert('b' == extracted2ch_Cvf_nt)
+
+assert(1 == i_Cvf_nt.`a b`)
+assert(2 == i_Cvf_nt.a)
+assert('a' == ch_Cvf_nt.`a b`)
+assert('b' == ch_Cvf_nt.a)
+assert(2 == i_Cvf_nt.p2)
+assert('b' == ch_Cvf_nt.p2)
+
+
+val ch_Cvf_nf = new Cvf_nf('a', 'b')
+val i_Cvf_nf = new Cvf_nf(1, 2)
+val Cvf_nf(extracted1i_Cvf_nf, extracted2i_Cvf_nf) = i_Cvf_nf
+val Cvf_nf(extracted1ch_Cvf_nf, extracted2ch_Cvf_nf) = ch_Cvf_nf
+assert(1 == extracted1i_Cvf_nf)
+assert(2 == extracted2i_Cvf_nf)
+assert('a' == extracted1ch_Cvf_nf)
+assert('b' == extracted2ch_Cvf_nf)
+
+assert(1 == i_Cvf_nf.`a b`)
+assert(2 == i_Cvf_nf.a)
+assert('a' == ch_Cvf_nf.`a b`)
+assert('b' == ch_Cvf_nf.a)
+
+
+val ch_Cnt_pvt = new Cnt_pvt('a', 'b')
+val i_Cnt_pvt = new Cnt_pvt(1, 2)
+val Cnt_pvt(extracted1i_Cnt_pvt, extracted2i_Cnt_pvt) = i_Cnt_pvt
+val Cnt_pvt(extracted1ch_Cnt_pvt, extracted2ch_Cnt_pvt) = ch_Cnt_pvt
+assert(1 == extracted1i_Cnt_pvt)
+assert(2 == extracted2i_Cnt_pvt)
+assert('a' == extracted1ch_Cnt_pvt)
+assert('b' == extracted2ch_Cnt_pvt)
+
+assert(1 == i_Cnt_pvt.`a b`)
+assert('a' == ch_Cnt_pvt.`a b`)
+assert(1 == i_Cnt_pvt.p1)
+assert(2 == i_Cnt_pvt.p2)
+assert('a' == ch_Cnt_pvt.p1)
+assert('b' == ch_Cnt_pvt.p2)
+
+
+val ch_Cnt_pvf = new Cnt_pvf('a', 'b')
+val i_Cnt_pvf = new Cnt_pvf(1, 2)
+val Cnt_pvf(extracted1i_Cnt_pvf, extracted2i_Cnt_pvf) = i_Cnt_pvf
+val Cnt_pvf(extracted1ch_Cnt_pvf, extracted2ch_Cnt_pvf) = ch_Cnt_pvf
+assert(1 == extracted1i_Cnt_pvf)
+assert(2 == extracted2i_Cnt_pvf)
+assert('a' == extracted1ch_Cnt_pvf)
+assert('b' == extracted2ch_Cnt_pvf)
+
+assert(1 == i_Cnt_pvf.`a b`)
+assert('a' == ch_Cnt_pvf.`a b`)
+assert(1 == i_Cnt_pvf.p1)
+assert('a' == ch_Cnt_pvf.p1)
+
+
+val ch_Cnt_vt = new Cnt_vt('a', 'b')
+val i_Cnt_vt = new Cnt_vt(1, 2)
+val Cnt_vt(extracted1i_Cnt_vt, extracted2i_Cnt_vt) = i_Cnt_vt
+val Cnt_vt(extracted1ch_Cnt_vt, extracted2ch_Cnt_vt) = ch_Cnt_vt
+assert(1 == extracted1i_Cnt_vt)
+assert(2 == extracted2i_Cnt_vt)
+assert('a' == extracted1ch_Cnt_vt)
+assert('b' == extracted2ch_Cnt_vt)
+
+assert(1 == i_Cnt_vt.`a b`)
+assert(2 == i_Cnt_vt.a)
+assert('a' == ch_Cnt_vt.`a b`)
+assert('b' == ch_Cnt_vt.a)
+assert(1 == i_Cnt_vt.p1)
+assert(2 == i_Cnt_vt.p2)
+assert('a' == ch_Cnt_vt.p1)
+assert('b' == ch_Cnt_vt.p2)
+
+
+val ch_Cnt_vf = new Cnt_vf('a', 'b')
+val i_Cnt_vf = new Cnt_vf(1, 2)
+val Cnt_vf(extracted1i_Cnt_vf, extracted2i_Cnt_vf) = i_Cnt_vf
+val Cnt_vf(extracted1ch_Cnt_vf, extracted2ch_Cnt_vf) = ch_Cnt_vf
+assert(1 == extracted1i_Cnt_vf)
+assert(2 == extracted2i_Cnt_vf)
+assert('a' == extracted1ch_Cnt_vf)
+assert('b' == extracted2ch_Cnt_vf)
+
+assert(1 == i_Cnt_vf.`a b`)
+assert(2 == i_Cnt_vf.a)
+assert('a' == ch_Cnt_vf.`a b`)
+assert('b' == ch_Cnt_vf.a)
+assert(1 == i_Cnt_vf.p1)
+assert('a' == ch_Cnt_vf.p1)
+
+
+val ch_Cnt_nt = new Cnt_nt('a', 'b')
+val i_Cnt_nt = new Cnt_nt(1, 2)
+val Cnt_nt(extracted1i_Cnt_nt, extracted2i_Cnt_nt) = i_Cnt_nt
+val Cnt_nt(extracted1ch_Cnt_nt, extracted2ch_Cnt_nt) = ch_Cnt_nt
+assert(1 == extracted1i_Cnt_nt)
+assert(2 == extracted2i_Cnt_nt)
+assert('a' == extracted1ch_Cnt_nt)
+assert('b' == extracted2ch_Cnt_nt)
+
+assert(1 == i_Cnt_nt.`a b`)
+assert(2 == i_Cnt_nt.a)
+assert('a' == ch_Cnt_nt.`a b`)
+assert('b' == ch_Cnt_nt.a)
+assert(1 == i_Cnt_nt.p1)
+assert(2 == i_Cnt_nt.p2)
+assert('a' == ch_Cnt_nt.p1)
+assert('b' == ch_Cnt_nt.p2)
+
+
+val ch_Cnt_nf = new Cnt_nf('a', 'b')
+val i_Cnt_nf = new Cnt_nf(1, 2)
+val Cnt_nf(extracted1i_Cnt_nf, extracted2i_Cnt_nf) = i_Cnt_nf
+val Cnt_nf(extracted1ch_Cnt_nf, extracted2ch_Cnt_nf) = ch_Cnt_nf
+assert(1 == extracted1i_Cnt_nf)
+assert(2 == extracted2i_Cnt_nf)
+assert('a' == extracted1ch_Cnt_nf)
+assert('b' == extracted2ch_Cnt_nf)
+
+assert(1 == i_Cnt_nf.`a b`)
+assert(2 == i_Cnt_nf.a)
+assert('a' == ch_Cnt_nf.`a b`)
+assert('b' == ch_Cnt_nf.a)
+assert(1 == i_Cnt_nf.p1)
+assert('a' == ch_Cnt_nf.p1)
+
+
+val ch_Cnf_pvt = new Cnf_pvt('a', 'b')
+val i_Cnf_pvt = new Cnf_pvt(1, 2)
+val Cnf_pvt(extracted1i_Cnf_pvt, extracted2i_Cnf_pvt) = i_Cnf_pvt
+val Cnf_pvt(extracted1ch_Cnf_pvt, extracted2ch_Cnf_pvt) = ch_Cnf_pvt
+assert(1 == extracted1i_Cnf_pvt)
+assert(2 == extracted2i_Cnf_pvt)
+assert('a' == extracted1ch_Cnf_pvt)
+assert('b' == extracted2ch_Cnf_pvt)
+
+assert(1 == i_Cnf_pvt.`a b`)
+assert('a' == ch_Cnf_pvt.`a b`)
+assert(2 == i_Cnf_pvt.p2)
+assert('b' == ch_Cnf_pvt.p2)
+
+
+val ch_Cnf_pvf = new Cnf_pvf('a', 'b')
+val i_Cnf_pvf = new Cnf_pvf(1, 2)
+val Cnf_pvf(extracted1i_Cnf_pvf, extracted2i_Cnf_pvf) = i_Cnf_pvf
+val Cnf_pvf(extracted1ch_Cnf_pvf, extracted2ch_Cnf_pvf) = ch_Cnf_pvf
+assert(1 == extracted1i_Cnf_pvf)
+assert(2 == extracted2i_Cnf_pvf)
+assert('a' == extracted1ch_Cnf_pvf)
+assert('b' == extracted2ch_Cnf_pvf)
+
+assert(1 == i_Cnf_pvf.`a b`)
+assert('a' == ch_Cnf_pvf.`a b`)
+
+
+val ch_Cnf_vt = new Cnf_vt('a', 'b')
+val i_Cnf_vt = new Cnf_vt(1, 2)
+val Cnf_vt(extracted1i_Cnf_vt, extracted2i_Cnf_vt) = i_Cnf_vt
+val Cnf_vt(extracted1ch_Cnf_vt, extracted2ch_Cnf_vt) = ch_Cnf_vt
+assert(1 == extracted1i_Cnf_vt)
+assert(2 == extracted2i_Cnf_vt)
+assert('a' == extracted1ch_Cnf_vt)
+assert('b' == extracted2ch_Cnf_vt)
+
+assert(1 == i_Cnf_vt.`a b`)
+assert(2 == i_Cnf_vt.a)
+assert('a' == ch_Cnf_vt.`a b`)
+assert('b' == ch_Cnf_vt.a)
+assert(2 == i_Cnf_vt.p2)
+assert('b' == ch_Cnf_vt.p2)
+
+
+val ch_Cnf_vf = new Cnf_vf('a', 'b')
+val i_Cnf_vf = new Cnf_vf(1, 2)
+val Cnf_vf(extracted1i_Cnf_vf, extracted2i_Cnf_vf) = i_Cnf_vf
+val Cnf_vf(extracted1ch_Cnf_vf, extracted2ch_Cnf_vf) = ch_Cnf_vf
+assert(1 == extracted1i_Cnf_vf)
+assert(2 == extracted2i_Cnf_vf)
+assert('a' == extracted1ch_Cnf_vf)
+assert('b' == extracted2ch_Cnf_vf)
+
+assert(1 == i_Cnf_vf.`a b`)
+assert(2 == i_Cnf_vf.a)
+assert('a' == ch_Cnf_vf.`a b`)
+assert('b' == ch_Cnf_vf.a)
+
+
+val ch_Cnf_nt = new Cnf_nt('a', 'b')
+val i_Cnf_nt = new Cnf_nt(1, 2)
+val Cnf_nt(extracted1i_Cnf_nt, extracted2i_Cnf_nt) = i_Cnf_nt
+val Cnf_nt(extracted1ch_Cnf_nt, extracted2ch_Cnf_nt) = ch_Cnf_nt
+assert(1 == extracted1i_Cnf_nt)
+assert(2 == extracted2i_Cnf_nt)
+assert('a' == extracted1ch_Cnf_nt)
+assert('b' == extracted2ch_Cnf_nt)
+
+assert(1 == i_Cnf_nt.`a b`)
+assert(2 == i_Cnf_nt.a)
+assert('a' == ch_Cnf_nt.`a b`)
+assert('b' == ch_Cnf_nt.a)
+assert(2 == i_Cnf_nt.p2)
+assert('b' == ch_Cnf_nt.p2)
+
+
+val ch_Cnf_nf = new Cnf_nf('a', 'b')
+val i_Cnf_nf = new Cnf_nf(1, 2)
+val Cnf_nf(extracted1i_Cnf_nf, extracted2i_Cnf_nf) = i_Cnf_nf
+val Cnf_nf(extracted1ch_Cnf_nf, extracted2ch_Cnf_nf) = ch_Cnf_nf
+assert(1 == extracted1i_Cnf_nf)
+assert(2 == extracted2i_Cnf_nf)
+assert('a' == extracted1ch_Cnf_nf)
+assert('b' == extracted2ch_Cnf_nf)
+
+assert(1 == i_Cnf_nf.`a b`)
+assert(2 == i_Cnf_nf.a)
+assert('a' == ch_Cnf_nf.`a b`)
+assert('b' == ch_Cnf_nf.a)
+
+
+val ch_Rpvt_pvt = new Rpvt_pvt('a', 'b')
+val i_Rpvt_pvt = new Rpvt_pvt(1, 2)
+assert(1 == i_Rpvt_pvt.p1)
+assert(2 == i_Rpvt_pvt.p2)
+assert('a' == ch_Rpvt_pvt.p1)
+assert('b' == ch_Rpvt_pvt.p2)
+
+
+val ch_Rpvt_pvf = new Rpvt_pvf('a', 'b')
+val i_Rpvt_pvf = new Rpvt_pvf(1, 2)
+assert(1 == i_Rpvt_pvf.p1)
+assert('a' == ch_Rpvt_pvf.p1)
+
+
+val ch_Rpvt_vt = new Rpvt_vt('a', 'b')
+val i_Rpvt_vt = new Rpvt_vt(1, 2)
+assert(2 == i_Rpvt_vt.a)
+assert('b' == ch_Rpvt_vt.a)
+assert(1 == i_Rpvt_vt.p1)
+assert(2 == i_Rpvt_vt.p2)
+assert('a' == ch_Rpvt_vt.p1)
+assert('b' == ch_Rpvt_vt.p2)
+
+
+val ch_Rpvt_vf = new Rpvt_vf('a', 'b')
+val i_Rpvt_vf = new Rpvt_vf(1, 2)
+assert(2 == i_Rpvt_vf.a)
+assert('b' == ch_Rpvt_vf.a)
+assert(1 == i_Rpvt_vf.p1)
+assert('a' == ch_Rpvt_vf.p1)
+
+
+val ch_Rpvt_nt = new Rpvt_nt('a', 'b')
+val i_Rpvt_nt = new Rpvt_nt(1, 2)
+assert(1 == i_Rpvt_nt.p1)
+assert(2 == i_Rpvt_nt.p2)
+assert('a' == ch_Rpvt_nt.p1)
+assert('b' == ch_Rpvt_nt.p2)
+
+
+val ch_Rpvt_nf = new Rpvt_nf('a', 'b')
+val i_Rpvt_nf = new Rpvt_nf(1, 2)
+assert(1 == i_Rpvt_nf.p1)
+assert('a' == ch_Rpvt_nf.p1)
+
+
+val ch_Rpvf_pvt = new Rpvf_pvt('a', 'b')
+val i_Rpvf_pvt = new Rpvf_pvt(1, 2)
+assert(2 == i_Rpvf_pvt.p2)
+assert('b' == ch_Rpvf_pvt.p2)
 
-val ch_Rtvtvf = new Rtvtvf('a', 'b')
-val i_Rtvtvf = new Rtvtvf(1, 2)
-assert(1 == i_Rtvtvf.`a b`)
-assert(2 == i_Rtvtvf.a)
-assert('a' == ch_Rtvtvf.`a b`)
-assert('b' == ch_Rtvtvf.a)
-assert(1 == i_Rtvtvf.p1)
-assert('a' == ch_Rtvtvf.p1)
 
-
-val ch_Rtvtnt = new Rtvtnt('a', 'b')
-val i_Rtvtnt = new Rtvtnt(1, 2)
-assert(1 == i_Rtvtnt.`a b`)
-assert('a' == ch_Rtvtnt.`a b`)
-assert(1 == i_Rtvtnt.p1)
-assert(2 == i_Rtvtnt.p2)
-assert('a' == ch_Rtvtnt.p1)
-assert('b' == ch_Rtvtnt.p2)
+val ch_Rpvf_pvf = new Rpvf_pvf('a', 'b')
+val i_Rpvf_pvf = new Rpvf_pvf(1, 2)
+
+
+val ch_Rpvf_vt = new Rpvf_vt('a', 'b')
+val i_Rpvf_vt = new Rpvf_vt(1, 2)
+assert(2 == i_Rpvf_vt.a)
+assert('b' == ch_Rpvf_vt.a)
+assert(2 == i_Rpvf_vt.p2)
+assert('b' == ch_Rpvf_vt.p2)
 
 
-val ch_Rtvtnf = new Rtvtnf('a', 'b')
-val i_Rtvtnf = new Rtvtnf(1, 2)
-assert(1 == i_Rtvtnf.`a b`)
-assert('a' == ch_Rtvtnf.`a b`)
-assert(1 == i_Rtvtnf.p1)
-assert('a' == ch_Rtvtnf.p1)
+val ch_Rpvf_vf = new Rpvf_vf('a', 'b')
+val i_Rpvf_vf = new Rpvf_vf(1, 2)
+assert(2 == i_Rpvf_vf.a)
+assert('b' == ch_Rpvf_vf.a)
+
 
+val ch_Rpvf_nt = new Rpvf_nt('a', 'b')
+val i_Rpvf_nt = new Rpvf_nt(1, 2)
+assert(2 == i_Rpvf_nt.p2)
+assert('b' == ch_Rpvf_nt.p2)
 
-val ch_Rtvfpvt = new Rtvfpvt('a', 'b')
-val i_Rtvfpvt = new Rtvfpvt(1, 2)
-assert(1 == i_Rtvfpvt.`a b`)
-assert('a' == ch_Rtvfpvt.`a b`)
-assert(2 == i_Rtvfpvt.p2)
-assert('b' == ch_Rtvfpvt.p2)
 
+val ch_Rpvf_nf = new Rpvf_nf('a', 'b')
+val i_Rpvf_nf = new Rpvf_nf(1, 2)
 
-val ch_Rtvfvt = new Rtvfvt('a', 'b')
-val i_Rtvfvt = new Rtvfvt(1, 2)
-assert(1 == i_Rtvfvt.`a b`)
-assert(2 == i_Rtvfvt.a)
-assert('a' == ch_Rtvfvt.`a b`)
-assert('b' == ch_Rtvfvt.a)
-assert(2 == i_Rtvfvt.p2)
-assert('b' == ch_Rtvfvt.p2)
 
+val ch_Rvt_pvt = new Rvt_pvt('a', 'b')
+val i_Rvt_pvt = new Rvt_pvt(1, 2)
+assert(1 == i_Rvt_pvt.`a b`)
+assert('a' == ch_Rvt_pvt.`a b`)
+assert(1 == i_Rvt_pvt.p1)
+assert(2 == i_Rvt_pvt.p2)
+assert('a' == ch_Rvt_pvt.p1)
+assert('b' == ch_Rvt_pvt.p2)
 
-val ch_Rtvfnt = new Rtvfnt('a', 'b')
-val i_Rtvfnt = new Rtvfnt(1, 2)
-assert(1 == i_Rtvfnt.`a b`)
-assert('a' == ch_Rtvfnt.`a b`)
-assert(2 == i_Rtvfnt.p2)
-assert('b' == ch_Rtvfnt.p2)
 
+val ch_Rvt_pvf = new Rvt_pvf('a', 'b')
+val i_Rvt_pvf = new Rvt_pvf(1, 2)
+assert(1 == i_Rvt_pvf.`a b`)
+assert('a' == ch_Rvt_pvf.`a b`)
+assert(1 == i_Rvt_pvf.p1)
+assert('a' == ch_Rvt_pvf.p1)
 
-val ch_Rtntpvt = new Rtntpvt('a', 'b')
-val i_Rtntpvt = new Rtntpvt(1, 2)
-assert(1 == i_Rtntpvt.p1)
-assert(2 == i_Rtntpvt.p2)
-assert('a' == ch_Rtntpvt.p1)
-assert('b' == ch_Rtntpvt.p2)
 
+val ch_Rvt_vt = new Rvt_vt('a', 'b')
+val i_Rvt_vt = new Rvt_vt(1, 2)
+assert(1 == i_Rvt_vt.`a b`)
+assert(2 == i_Rvt_vt.a)
+assert('a' == ch_Rvt_vt.`a b`)
+assert('b' == ch_Rvt_vt.a)
+assert(1 == i_Rvt_vt.p1)
+assert(2 == i_Rvt_vt.p2)
+assert('a' == ch_Rvt_vt.p1)
+assert('b' == ch_Rvt_vt.p2)
 
-val ch_Rtntpvf = new Rtntpvf('a', 'b')
-val i_Rtntpvf = new Rtntpvf(1, 2)
-assert(1 == i_Rtntpvf.p1)
-assert('a' == ch_Rtntpvf.p1)
 
+val ch_Rvt_vf = new Rvt_vf('a', 'b')
+val i_Rvt_vf = new Rvt_vf(1, 2)
+assert(1 == i_Rvt_vf.`a b`)
+assert(2 == i_Rvt_vf.a)
+assert('a' == ch_Rvt_vf.`a b`)
+assert('b' == ch_Rvt_vf.a)
+assert(1 == i_Rvt_vf.p1)
+assert('a' == ch_Rvt_vf.p1)
 
-val ch_Rtntvt = new Rtntvt('a', 'b')
-val i_Rtntvt = new Rtntvt(1, 2)
-assert(2 == i_Rtntvt.a)
-assert('b' == ch_Rtntvt.a)
-assert(1 == i_Rtntvt.p1)
-assert(2 == i_Rtntvt.p2)
-assert('a' == ch_Rtntvt.p1)
-assert('b' == ch_Rtntvt.p2)
 
+val ch_Rvt_nt = new Rvt_nt('a', 'b')
+val i_Rvt_nt = new Rvt_nt(1, 2)
+assert(1 == i_Rvt_nt.`a b`)
+assert('a' == ch_Rvt_nt.`a b`)
+assert(1 == i_Rvt_nt.p1)
+assert(2 == i_Rvt_nt.p2)
+assert('a' == ch_Rvt_nt.p1)
+assert('b' == ch_Rvt_nt.p2)
 
-val ch_Rtntvf = new Rtntvf('a', 'b')
-val i_Rtntvf = new Rtntvf(1, 2)
-assert(2 == i_Rtntvf.a)
-assert('b' == ch_Rtntvf.a)
-assert(1 == i_Rtntvf.p1)
-assert('a' == ch_Rtntvf.p1)
 
+val ch_Rvt_nf = new Rvt_nf('a', 'b')
+val i_Rvt_nf = new Rvt_nf(1, 2)
+assert(1 == i_Rvt_nf.`a b`)
+assert('a' == ch_Rvt_nf.`a b`)
+assert(1 == i_Rvt_nf.p1)
+assert('a' == ch_Rvt_nf.p1)
 
-val ch_Rtntnt = new Rtntnt('a', 'b')
-val i_Rtntnt = new Rtntnt(1, 2)
-assert(1 == i_Rtntnt.p1)
-assert(2 == i_Rtntnt.p2)
-assert('a' == ch_Rtntnt.p1)
-assert('b' == ch_Rtntnt.p2)
 
+val ch_Rvf_pvt = new Rvf_pvt('a', 'b')
+val i_Rvf_pvt = new Rvf_pvt(1, 2)
+assert(1 == i_Rvf_pvt.`a b`)
+assert('a' == ch_Rvf_pvt.`a b`)
+assert(2 == i_Rvf_pvt.p2)
+assert('b' == ch_Rvf_pvt.p2)
 
-val ch_Rtntnf = new Rtntnf('a', 'b')
-val i_Rtntnf = new Rtntnf(1, 2)
-assert(1 == i_Rtntnf.p1)
-assert('a' == ch_Rtntnf.p1)
 
+val ch_Rvf_pvf = new Rvf_pvf('a', 'b')
+val i_Rvf_pvf = new Rvf_pvf(1, 2)
+assert(1 == i_Rvf_pvf.`a b`)
+assert('a' == ch_Rvf_pvf.`a b`)
 
-val ch_Rtnfpvt = new Rtnfpvt('a', 'b')
-val i_Rtnfpvt = new Rtnfpvt(1, 2)
-assert(2 == i_Rtnfpvt.p2)
-assert('b' == ch_Rtnfpvt.p2)
 
+val ch_Rvf_vt = new Rvf_vt('a', 'b')
+val i_Rvf_vt = new Rvf_vt(1, 2)
+assert(1 == i_Rvf_vt.`a b`)
+assert(2 == i_Rvf_vt.a)
+assert('a' == ch_Rvf_vt.`a b`)
+assert('b' == ch_Rvf_vt.a)
+assert(2 == i_Rvf_vt.p2)
+assert('b' == ch_Rvf_vt.p2)
 
-val ch_Rtnfvt = new Rtnfvt('a', 'b')
-val i_Rtnfvt = new Rtnfvt(1, 2)
-assert(2 == i_Rtnfvt.a)
-assert('b' == ch_Rtnfvt.a)
-assert(2 == i_Rtnfvt.p2)
-assert('b' == ch_Rtnfvt.p2)
 
+val ch_Rvf_vf = new Rvf_vf('a', 'b')
+val i_Rvf_vf = new Rvf_vf(1, 2)
+assert(1 == i_Rvf_vf.`a b`)
+assert(2 == i_Rvf_vf.a)
+assert('a' == ch_Rvf_vf.`a b`)
+assert('b' == ch_Rvf_vf.a)
 
-val ch_Rtnfnt = new Rtnfnt('a', 'b')
-val i_Rtnfnt = new Rtnfnt(1, 2)
-assert(2 == i_Rtnfnt.p2)
-assert('b' == ch_Rtnfnt.p2)
 
+val ch_Rvf_nt = new Rvf_nt('a', 'b')
+val i_Rvf_nt = new Rvf_nt(1, 2)
+assert(1 == i_Rvf_nt.`a b`)
+assert('a' == ch_Rvf_nt.`a b`)
+assert(2 == i_Rvf_nt.p2)
+assert('b' == ch_Rvf_nt.p2)
 
-val ch_Rfpvtpvt = new Rfpvtpvt('a', 'b')
-val i_Rfpvtpvt = new Rfpvtpvt(1, 2)
-assert(1 == i_Rfpvtpvt.p1)
-assert(2 == i_Rfpvtpvt.p2)
-assert('a' == ch_Rfpvtpvt.p1)
-assert('b' == ch_Rfpvtpvt.p2)
 
+val ch_Rvf_nf = new Rvf_nf('a', 'b')
+val i_Rvf_nf = new Rvf_nf(1, 2)
+assert(1 == i_Rvf_nf.`a b`)
+assert('a' == ch_Rvf_nf.`a b`)
 
-val ch_Rfpvtpvf = new Rfpvtpvf('a', 'b')
-val i_Rfpvtpvf = new Rfpvtpvf(1, 2)
-assert(1 == i_Rfpvtpvf.p1)
-assert('a' == ch_Rfpvtpvf.p1)
 
+val ch_Rnt_pvt = new Rnt_pvt('a', 'b')
+val i_Rnt_pvt = new Rnt_pvt(1, 2)
+assert(1 == i_Rnt_pvt.p1)
+assert(2 == i_Rnt_pvt.p2)
+assert('a' == ch_Rnt_pvt.p1)
+assert('b' == ch_Rnt_pvt.p2)
 
-val ch_Rfpvtvt = new Rfpvtvt('a', 'b')
-val i_Rfpvtvt = new Rfpvtvt(1, 2)
-assert(2 == i_Rfpvtvt.a)
-assert('b' == ch_Rfpvtvt.a)
-assert(1 == i_Rfpvtvt.p1)
-assert(2 == i_Rfpvtvt.p2)
-assert('a' == ch_Rfpvtvt.p1)
-assert('b' == ch_Rfpvtvt.p2)
 
+val ch_Rnt_pvf = new Rnt_pvf('a', 'b')
+val i_Rnt_pvf = new Rnt_pvf(1, 2)
+assert(1 == i_Rnt_pvf.p1)
+assert('a' == ch_Rnt_pvf.p1)
 
-val ch_Rfpvtvf = new Rfpvtvf('a', 'b')
-val i_Rfpvtvf = new Rfpvtvf(1, 2)
-assert(2 == i_Rfpvtvf.a)
-assert('b' == ch_Rfpvtvf.a)
-assert(1 == i_Rfpvtvf.p1)
-assert('a' == ch_Rfpvtvf.p1)
 
+val ch_Rnt_vt = new Rnt_vt('a', 'b')
+val i_Rnt_vt = new Rnt_vt(1, 2)
+assert(2 == i_Rnt_vt.a)
+assert('b' == ch_Rnt_vt.a)
+assert(1 == i_Rnt_vt.p1)
+assert(2 == i_Rnt_vt.p2)
+assert('a' == ch_Rnt_vt.p1)
+assert('b' == ch_Rnt_vt.p2)
 
-val ch_Rfpvtnt = new Rfpvtnt('a', 'b')
-val i_Rfpvtnt = new Rfpvtnt(1, 2)
-assert(1 == i_Rfpvtnt.p1)
-assert(2 == i_Rfpvtnt.p2)
-assert('a' == ch_Rfpvtnt.p1)
-assert('b' == ch_Rfpvtnt.p2)
 
+val ch_Rnt_vf = new Rnt_vf('a', 'b')
+val i_Rnt_vf = new Rnt_vf(1, 2)
+assert(2 == i_Rnt_vf.a)
+assert('b' == ch_Rnt_vf.a)
+assert(1 == i_Rnt_vf.p1)
+assert('a' == ch_Rnt_vf.p1)
 
-val ch_Rfpvtnf = new Rfpvtnf('a', 'b')
-val i_Rfpvtnf = new Rfpvtnf(1, 2)
-assert(1 == i_Rfpvtnf.p1)
-assert('a' == ch_Rfpvtnf.p1)
 
+val ch_Rnt_nt = new Rnt_nt('a', 'b')
+val i_Rnt_nt = new Rnt_nt(1, 2)
+assert(1 == i_Rnt_nt.p1)
+assert(2 == i_Rnt_nt.p2)
+assert('a' == ch_Rnt_nt.p1)
+assert('b' == ch_Rnt_nt.p2)
 
-val ch_Rfpvfpvt = new Rfpvfpvt('a', 'b')
-val i_Rfpvfpvt = new Rfpvfpvt(1, 2)
-assert(2 == i_Rfpvfpvt.p2)
-assert('b' == ch_Rfpvfpvt.p2)
 
+val ch_Rnt_nf = new Rnt_nf('a', 'b')
+val i_Rnt_nf = new Rnt_nf(1, 2)
+assert(1 == i_Rnt_nf.p1)
+assert('a' == ch_Rnt_nf.p1)
 
-val ch_Rfpvfpvf = new Rfpvfpvf('a', 'b')
-val i_Rfpvfpvf = new Rfpvfpvf(1, 2)
 
+val ch_Rnf_pvt = new Rnf_pvt('a', 'b')
+val i_Rnf_pvt = new Rnf_pvt(1, 2)
+assert(2 == i_Rnf_pvt.p2)
+assert('b' == ch_Rnf_pvt.p2)
 
-val ch_Rfpvfvt = new Rfpvfvt('a', 'b')
-val i_Rfpvfvt = new Rfpvfvt(1, 2)
-assert(2 == i_Rfpvfvt.a)
-assert('b' == ch_Rfpvfvt.a)
-assert(2 == i_Rfpvfvt.p2)
-assert('b' == ch_Rfpvfvt.p2)
 
+val ch_Rnf_pvf = new Rnf_pvf('a', 'b')
+val i_Rnf_pvf = new Rnf_pvf(1, 2)
 
-val ch_Rfpvfvf = new Rfpvfvf('a', 'b')
-val i_Rfpvfvf = new Rfpvfvf(1, 2)
-assert(2 == i_Rfpvfvf.a)
-assert('b' == ch_Rfpvfvf.a)
 
+val ch_Rnf_vt = new Rnf_vt('a', 'b')
+val i_Rnf_vt = new Rnf_vt(1, 2)
+assert(2 == i_Rnf_vt.a)
+assert('b' == ch_Rnf_vt.a)
+assert(2 == i_Rnf_vt.p2)
+assert('b' == ch_Rnf_vt.p2)
 
-val ch_Rfpvfnt = new Rfpvfnt('a', 'b')
-val i_Rfpvfnt = new Rfpvfnt(1, 2)
-assert(2 == i_Rfpvfnt.p2)
-assert('b' == ch_Rfpvfnt.p2)
 
+val ch_Rnf_vf = new Rnf_vf('a', 'b')
+val i_Rnf_vf = new Rnf_vf(1, 2)
+assert(2 == i_Rnf_vf.a)
+assert('b' == ch_Rnf_vf.a)
 
-val ch_Rfpvfnf = new Rfpvfnf('a', 'b')
-val i_Rfpvfnf = new Rfpvfnf(1, 2)
 
+val ch_Rnf_nt = new Rnf_nt('a', 'b')
+val i_Rnf_nt = new Rnf_nt(1, 2)
+assert(2 == i_Rnf_nt.p2)
+assert('b' == ch_Rnf_nt.p2)
 
-val ch_Rfvtpvt = new Rfvtpvt('a', 'b')
-val i_Rfvtpvt = new Rfvtpvt(1, 2)
-assert(1 == i_Rfvtpvt.`a b`)
-assert('a' == ch_Rfvtpvt.`a b`)
-assert(1 == i_Rfvtpvt.p1)
-assert(2 == i_Rfvtpvt.p2)
-assert('a' == ch_Rfvtpvt.p1)
-assert('b' == ch_Rfvtpvt.p2)
 
-
-val ch_Rfvtpvf = new Rfvtpvf('a', 'b')
-val i_Rfvtpvf = new Rfvtpvf(1, 2)
-assert(1 == i_Rfvtpvf.`a b`)
-assert('a' == ch_Rfvtpvf.`a b`)
-assert(1 == i_Rfvtpvf.p1)
-assert('a' == ch_Rfvtpvf.p1)
-
-
-val ch_Rfvtvt = new Rfvtvt('a', 'b')
-val i_Rfvtvt = new Rfvtvt(1, 2)
-assert(1 == i_Rfvtvt.`a b`)
-assert(2 == i_Rfvtvt.a)
-assert('a' == ch_Rfvtvt.`a b`)
-assert('b' == ch_Rfvtvt.a)
-assert(1 == i_Rfvtvt.p1)
-assert(2 == i_Rfvtvt.p2)
-assert('a' == ch_Rfvtvt.p1)
-assert('b' == ch_Rfvtvt.p2)
-
-
-val ch_Rfvtvf = new Rfvtvf('a', 'b')
-val i_Rfvtvf = new Rfvtvf(1, 2)
-assert(1 == i_Rfvtvf.`a b`)
-assert(2 == i_Rfvtvf.a)
-assert('a' == ch_Rfvtvf.`a b`)
-assert('b' == ch_Rfvtvf.a)
-assert(1 == i_Rfvtvf.p1)
-assert('a' == ch_Rfvtvf.p1)
-
-
-val ch_Rfvtnt = new Rfvtnt('a', 'b')
-val i_Rfvtnt = new Rfvtnt(1, 2)
-assert(1 == i_Rfvtnt.`a b`)
-assert('a' == ch_Rfvtnt.`a b`)
-assert(1 == i_Rfvtnt.p1)
-assert(2 == i_Rfvtnt.p2)
-assert('a' == ch_Rfvtnt.p1)
-assert('b' == ch_Rfvtnt.p2)
-
-
-val ch_Rfvtnf = new Rfvtnf('a', 'b')
-val i_Rfvtnf = new Rfvtnf(1, 2)
-assert(1 == i_Rfvtnf.`a b`)
-assert('a' == ch_Rfvtnf.`a b`)
-assert(1 == i_Rfvtnf.p1)
-assert('a' == ch_Rfvtnf.p1)
-
-
-val ch_Rfvfpvt = new Rfvfpvt('a', 'b')
-val i_Rfvfpvt = new Rfvfpvt(1, 2)
-assert(1 == i_Rfvfpvt.`a b`)
-assert('a' == ch_Rfvfpvt.`a b`)
-assert(2 == i_Rfvfpvt.p2)
-assert('b' == ch_Rfvfpvt.p2)
-
-
-val ch_Rfvfpvf = new Rfvfpvf('a', 'b')
-val i_Rfvfpvf = new Rfvfpvf(1, 2)
-assert(1 == i_Rfvfpvf.`a b`)
-assert('a' == ch_Rfvfpvf.`a b`)
-
-
-val ch_Rfvfvt = new Rfvfvt('a', 'b')
-val i_Rfvfvt = new Rfvfvt(1, 2)
-assert(1 == i_Rfvfvt.`a b`)
-assert(2 == i_Rfvfvt.a)
-assert('a' == ch_Rfvfvt.`a b`)
-assert('b' == ch_Rfvfvt.a)
-assert(2 == i_Rfvfvt.p2)
-assert('b' == ch_Rfvfvt.p2)
-
-
-val ch_Rfvfvf = new Rfvfvf('a', 'b')
-val i_Rfvfvf = new Rfvfvf(1, 2)
-assert(1 == i_Rfvfvf.`a b`)
-assert(2 == i_Rfvfvf.a)
-assert('a' == ch_Rfvfvf.`a b`)
-assert('b' == ch_Rfvfvf.a)
-
-
-val ch_Rfvfnt = new Rfvfnt('a', 'b')
-val i_Rfvfnt = new Rfvfnt(1, 2)
-assert(1 == i_Rfvfnt.`a b`)
-assert('a' == ch_Rfvfnt.`a b`)
-assert(2 == i_Rfvfnt.p2)
-assert('b' == ch_Rfvfnt.p2)
-
-
-val ch_Rfvfnf = new Rfvfnf('a', 'b')
-val i_Rfvfnf = new Rfvfnf(1, 2)
-assert(1 == i_Rfvfnf.`a b`)
-assert('a' == ch_Rfvfnf.`a b`)
-
-
-val ch_Rfntpvt = new Rfntpvt('a', 'b')
-val i_Rfntpvt = new Rfntpvt(1, 2)
-assert(1 == i_Rfntpvt.p1)
-assert(2 == i_Rfntpvt.p2)
-assert('a' == ch_Rfntpvt.p1)
-assert('b' == ch_Rfntpvt.p2)
-
-
-val ch_Rfntpvf = new Rfntpvf('a', 'b')
-val i_Rfntpvf = new Rfntpvf(1, 2)
-assert(1 == i_Rfntpvf.p1)
-assert('a' == ch_Rfntpvf.p1)
-
-
-val ch_Rfntvt = new Rfntvt('a', 'b')
-val i_Rfntvt = new Rfntvt(1, 2)
-assert(2 == i_Rfntvt.a)
-assert('b' == ch_Rfntvt.a)
-assert(1 == i_Rfntvt.p1)
-assert(2 == i_Rfntvt.p2)
-assert('a' == ch_Rfntvt.p1)
-assert('b' == ch_Rfntvt.p2)
-
-
-val ch_Rfntvf = new Rfntvf('a', 'b')
-val i_Rfntvf = new Rfntvf(1, 2)
-assert(2 == i_Rfntvf.a)
-assert('b' == ch_Rfntvf.a)
-assert(1 == i_Rfntvf.p1)
-assert('a' == ch_Rfntvf.p1)
-
-
-val ch_Rfntnt = new Rfntnt('a', 'b')
-val i_Rfntnt = new Rfntnt(1, 2)
-assert(1 == i_Rfntnt.p1)
-assert(2 == i_Rfntnt.p2)
-assert('a' == ch_Rfntnt.p1)
-assert('b' == ch_Rfntnt.p2)
-
-
-val ch_Rfntnf = new Rfntnf('a', 'b')
-val i_Rfntnf = new Rfntnf(1, 2)
-assert(1 == i_Rfntnf.p1)
-assert('a' == ch_Rfntnf.p1)
-
-
-val ch_Rfnfpvt = new Rfnfpvt('a', 'b')
-val i_Rfnfpvt = new Rfnfpvt(1, 2)
-assert(2 == i_Rfnfpvt.p2)
-assert('b' == ch_Rfnfpvt.p2)
-
-
-val ch_Rfnfpvf = new Rfnfpvf('a', 'b')
-val i_Rfnfpvf = new Rfnfpvf(1, 2)
-
-
-val ch_Rfnfvt = new Rfnfvt('a', 'b')
-val i_Rfnfvt = new Rfnfvt(1, 2)
-assert(2 == i_Rfnfvt.a)
-assert('b' == ch_Rfnfvt.a)
-assert(2 == i_Rfnfvt.p2)
-assert('b' == ch_Rfnfvt.p2)
-
-
-val ch_Rfnfvf = new Rfnfvf('a', 'b')
-val i_Rfnfvf = new Rfnfvf(1, 2)
-assert(2 == i_Rfnfvf.a)
-assert('b' == ch_Rfnfvf.a)
-
-
-val ch_Rfnfnt = new Rfnfnt('a', 'b')
-val i_Rfnfnt = new Rfnfnt(1, 2)
-assert(2 == i_Rfnfnt.p2)
-assert('b' == ch_Rfnfnt.p2)
-
-
-val ch_Rfnfnf = new Rfnfnf('a', 'b')
-val i_Rfnfnf = new Rfnfnf(1, 2)
+val ch_Rnf_nf = new Rnf_nf('a', 'b')
+val i_Rnf_nf = new Rnf_nf(1, 2)
 
 TestJoint.joint()
 }
diff --git a/test/files/run/t8831_many/generator.scala b/test/files/run/t8831_many/generator.scala
index 28defb5620d1..287dcde8f24c 100644
--- a/test/files/run/t8831_many/generator.scala
+++ b/test/files/run/t8831_many/generator.scala
@@ -1,11 +1,11 @@
 //Generate the classes and assertions under test.
-case class TestCase(classType: String, specialized: Boolean, p1: ParamConfig, p2: ParamConfig) {
-  val className = s"${classType.headOption.getOrElse('r')}${specialized.toString().head}${abbr(p1)}${abbr(p2)}".capitalize
-  val tparams = if (specialized) "[@specialized(Int) A, @specialized(Int) B]" else "[A, B]"
+case class TestCase(classType: String, p1: ParamConfig, p2: ParamConfig) {
+  val className = s"${classType.headOption.getOrElse('r')}${abbr(p1)}_${abbr(p2)}".capitalize
+  val tParams = "[@specialized(Int) A, @specialized(Int) B]"
   def abbr(p: ParamConfig): String = p.modifier.split(' ').toSeq.map(_.headOption.getOrElse('n')).mkString + p.accessed.toString().head
   //def access(param: ParamConfig, name: String) = if(param.accessed)
   def decl(param: ParamConfig): String = param.aliasName.map(n => s"val $n = ${param.constructorName}\n").getOrElse("")
-  def renderClass: String = s"""$classType class $className$tparams(${p1.modifier} ${p1.constructorName}: A, ${p2.modifier} a: B){
+  def renderClass: String = s"""$classType class $className$tParams(${p1.modifier} ${p1.constructorName}: A, ${p2.modifier} a: B){
     ${decl(p1)}${decl(p2)}
   }"""
   
@@ -52,11 +52,9 @@ object Generator {
 
   val configurations = for {
     classConfig <- List("case", "")
-    specialized <- List(true, false)
     p1config <- paramConfigurations("`a b`", "p1")
     p2config <- paramConfigurations("a", "p2")
-    if (!(specialized && !(p1config.accessed || p2config.accessed)))
-  } yield TestCase(classConfig, specialized, p1config, p2config)
+  } yield TestCase(classConfig, p1config, p2config)
 
   def main(args: Array[String]): Unit = {
     import java.io.File

From e52fb82bd90a9f32cd217cf6fb68078b8fb8f5d8 Mon Sep 17 00:00:00 2001
From: Martijn Hoekstra <martijn.hoekstra@cargoxs.com>
Date: Sat, 6 Jun 2020 10:43:01 +0200
Subject: [PATCH 4/4] reduce testcases

don't test unaccessed
---
 test/files/run/t8831_many/Classes_1.scala | 1427 +++++----------------
 test/files/run/t8831_many/Tests_2.scala   | 1067 ++++-----------
 test/files/run/t8831_many/generator.scala |   26 +-
 3 files changed, 565 insertions(+), 1955 deletions(-)

diff --git a/test/files/run/t8831_many/Classes_1.scala b/test/files/run/t8831_many/Classes_1.scala
index e75474b447bc..102caf4739cd 100644
--- a/test/files/run/t8831_many/Classes_1.scala
+++ b/test/files/run/t8831_many/Classes_1.scala
@@ -1,1120 +1,319 @@
-case class Cpvt_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cpvt_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
-case class Cpvt_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cpvt_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
-case class Cpvt_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cpvt_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
-case class Cpvf_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
-case class Cpvf_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    
-  }
-case class Cpvf_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    val p2 = a
-
-  }
-case class Cpvf_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    
-  }
-case class Cpvf_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    val p2 = a
-
-  }
-case class Cpvf_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    
-  }
-case class Cvt_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cvt_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
-case class Cvt_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cvt_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
-case class Cvt_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cvt_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
-case class Cvf_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
-case class Cvf_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    
-  }
-case class Cvf_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p2 = a
-
-  }
-case class Cvf_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    
-  }
-case class Cvf_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p2 = a
-
-  }
-case class Cvf_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    
-  }
-case class Cnt_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cnt_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
-case class Cnt_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cnt_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
-case class Cnt_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
-case class Cnt_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
-case class Cnf_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p2 = a
-
-  }
-case class Cnf_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    
-  }
-case class Cnf_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p2 = a
-
-  }
-case class Cnf_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    
-  }
-case class Cnf_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p2 = a
-
-  }
-case class Cnf_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    
-  }
- class Rpvt_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rpvt_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
- class Rpvt_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rpvt_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
- class Rpvt_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rpvt_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
- class Rpvf_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
- class Rpvf_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
-    
-  }
- class Rpvf_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    val p2 = a
-
-  }
- class Rpvf_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
-    
-  }
- class Rpvf_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    val p2 = a
-
-  }
- class Rpvf_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
-    
-  }
- class Rvt_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rvt_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
- class Rvt_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rvt_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
- class Rvt_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rvt_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
- class Rvf_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    val p2 = a
-
-  }
- class Rvf_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
-    
-  }
- class Rvf_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    val p2 = a
-
-  }
- class Rvf_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
-    
-  }
- class Rvf_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    val p2 = a
-
-  }
- class Rvf_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
-    
-  }
- class Rnt_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rnt_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p1 = `a b`
-
-  }
- class Rnt_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rnt_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p1 = `a b`
-
-  }
- class Rnt_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p1 = `a b`
-val p2 = a
-
-  }
- class Rnt_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p1 = `a b`
-
-  }
- class Rnf_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    val p2 = a
-
-  }
- class Rnf_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
-    
-  }
- class Rnf_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    val p2 = a
-
-  }
- class Rnf_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
-    
-  }
- class Rnf_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    val p2 = a
-
-  }
- class Rnf_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
-    
-  }
+case class Cpv_pv[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+case class Cpv_v[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+case class Cpv_n[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+case class Cv_pv[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+case class Cv_v[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+case class Cv_n[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+case class Cn_pv[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+case class Cn_v[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+case class Cn_n[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rpv_pv[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rpv_v[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rpv_n[@specialized(Int) A, @specialized(Int) B](private val `a b`: A,  a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rv_pv[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rv_v[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rv_n[@specialized(Int) A, @specialized(Int) B](val `a b`: A,  a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rn_pv[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rn_v[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){
+  val p1 = `a b`
+  val p2 = a
+}
+ class Rn_n[@specialized(Int) A, @specialized(Int) B]( `a b`: A,  a: B){
+  val p1 = `a b`
+  val p2 = a
+}
 object TestJoint  {
  def joint(): Unit = {
 
-val ch_Cpvt_pvt = new Cpvt_pvt('a', 'b')
-val i_Cpvt_pvt = new Cpvt_pvt(1, 2)
-val Cpvt_pvt(extracted1i_Cpvt_pvt, extracted2i_Cpvt_pvt) = i_Cpvt_pvt
-val Cpvt_pvt(extracted1ch_Cpvt_pvt, extracted2ch_Cpvt_pvt) = ch_Cpvt_pvt
-assert(1 == extracted1i_Cpvt_pvt)
-assert(2 == extracted2i_Cpvt_pvt)
-assert('a' == extracted1ch_Cpvt_pvt)
-assert('b' == extracted2ch_Cpvt_pvt)
-
-assert(1 == i_Cpvt_pvt.p1)
-assert(2 == i_Cpvt_pvt.p2)
-assert('a' == ch_Cpvt_pvt.p1)
-assert('b' == ch_Cpvt_pvt.p2)
-
-
-val ch_Cpvt_pvf = new Cpvt_pvf('a', 'b')
-val i_Cpvt_pvf = new Cpvt_pvf(1, 2)
-val Cpvt_pvf(extracted1i_Cpvt_pvf, extracted2i_Cpvt_pvf) = i_Cpvt_pvf
-val Cpvt_pvf(extracted1ch_Cpvt_pvf, extracted2ch_Cpvt_pvf) = ch_Cpvt_pvf
-assert(1 == extracted1i_Cpvt_pvf)
-assert(2 == extracted2i_Cpvt_pvf)
-assert('a' == extracted1ch_Cpvt_pvf)
-assert('b' == extracted2ch_Cpvt_pvf)
-
-assert(1 == i_Cpvt_pvf.p1)
-assert('a' == ch_Cpvt_pvf.p1)
-
-
-val ch_Cpvt_vt = new Cpvt_vt('a', 'b')
-val i_Cpvt_vt = new Cpvt_vt(1, 2)
-val Cpvt_vt(extracted1i_Cpvt_vt, extracted2i_Cpvt_vt) = i_Cpvt_vt
-val Cpvt_vt(extracted1ch_Cpvt_vt, extracted2ch_Cpvt_vt) = ch_Cpvt_vt
-assert(1 == extracted1i_Cpvt_vt)
-assert(2 == extracted2i_Cpvt_vt)
-assert('a' == extracted1ch_Cpvt_vt)
-assert('b' == extracted2ch_Cpvt_vt)
-
-assert(2 == i_Cpvt_vt.a)
-assert('b' == ch_Cpvt_vt.a)
-assert(1 == i_Cpvt_vt.p1)
-assert(2 == i_Cpvt_vt.p2)
-assert('a' == ch_Cpvt_vt.p1)
-assert('b' == ch_Cpvt_vt.p2)
-
-
-val ch_Cpvt_vf = new Cpvt_vf('a', 'b')
-val i_Cpvt_vf = new Cpvt_vf(1, 2)
-val Cpvt_vf(extracted1i_Cpvt_vf, extracted2i_Cpvt_vf) = i_Cpvt_vf
-val Cpvt_vf(extracted1ch_Cpvt_vf, extracted2ch_Cpvt_vf) = ch_Cpvt_vf
-assert(1 == extracted1i_Cpvt_vf)
-assert(2 == extracted2i_Cpvt_vf)
-assert('a' == extracted1ch_Cpvt_vf)
-assert('b' == extracted2ch_Cpvt_vf)
-
-assert(2 == i_Cpvt_vf.a)
-assert('b' == ch_Cpvt_vf.a)
-assert(1 == i_Cpvt_vf.p1)
-assert('a' == ch_Cpvt_vf.p1)
-
-
-val ch_Cpvt_nt = new Cpvt_nt('a', 'b')
-val i_Cpvt_nt = new Cpvt_nt(1, 2)
-val Cpvt_nt(extracted1i_Cpvt_nt, extracted2i_Cpvt_nt) = i_Cpvt_nt
-val Cpvt_nt(extracted1ch_Cpvt_nt, extracted2ch_Cpvt_nt) = ch_Cpvt_nt
-assert(1 == extracted1i_Cpvt_nt)
-assert(2 == extracted2i_Cpvt_nt)
-assert('a' == extracted1ch_Cpvt_nt)
-assert('b' == extracted2ch_Cpvt_nt)
-
-assert(2 == i_Cpvt_nt.a)
-assert('b' == ch_Cpvt_nt.a)
-assert(1 == i_Cpvt_nt.p1)
-assert(2 == i_Cpvt_nt.p2)
-assert('a' == ch_Cpvt_nt.p1)
-assert('b' == ch_Cpvt_nt.p2)
-
-
-val ch_Cpvt_nf = new Cpvt_nf('a', 'b')
-val i_Cpvt_nf = new Cpvt_nf(1, 2)
-val Cpvt_nf(extracted1i_Cpvt_nf, extracted2i_Cpvt_nf) = i_Cpvt_nf
-val Cpvt_nf(extracted1ch_Cpvt_nf, extracted2ch_Cpvt_nf) = ch_Cpvt_nf
-assert(1 == extracted1i_Cpvt_nf)
-assert(2 == extracted2i_Cpvt_nf)
-assert('a' == extracted1ch_Cpvt_nf)
-assert('b' == extracted2ch_Cpvt_nf)
-
-assert(2 == i_Cpvt_nf.a)
-assert('b' == ch_Cpvt_nf.a)
-assert(1 == i_Cpvt_nf.p1)
-assert('a' == ch_Cpvt_nf.p1)
-
-
-val ch_Cpvf_pvt = new Cpvf_pvt('a', 'b')
-val i_Cpvf_pvt = new Cpvf_pvt(1, 2)
-val Cpvf_pvt(extracted1i_Cpvf_pvt, extracted2i_Cpvf_pvt) = i_Cpvf_pvt
-val Cpvf_pvt(extracted1ch_Cpvf_pvt, extracted2ch_Cpvf_pvt) = ch_Cpvf_pvt
-assert(1 == extracted1i_Cpvf_pvt)
-assert(2 == extracted2i_Cpvf_pvt)
-assert('a' == extracted1ch_Cpvf_pvt)
-assert('b' == extracted2ch_Cpvf_pvt)
-
-assert(2 == i_Cpvf_pvt.p2)
-assert('b' == ch_Cpvf_pvt.p2)
-
-
-val ch_Cpvf_pvf = new Cpvf_pvf('a', 'b')
-val i_Cpvf_pvf = new Cpvf_pvf(1, 2)
-val Cpvf_pvf(extracted1i_Cpvf_pvf, extracted2i_Cpvf_pvf) = i_Cpvf_pvf
-val Cpvf_pvf(extracted1ch_Cpvf_pvf, extracted2ch_Cpvf_pvf) = ch_Cpvf_pvf
-assert(1 == extracted1i_Cpvf_pvf)
-assert(2 == extracted2i_Cpvf_pvf)
-assert('a' == extracted1ch_Cpvf_pvf)
-assert('b' == extracted2ch_Cpvf_pvf)
-
-
-
-val ch_Cpvf_vt = new Cpvf_vt('a', 'b')
-val i_Cpvf_vt = new Cpvf_vt(1, 2)
-val Cpvf_vt(extracted1i_Cpvf_vt, extracted2i_Cpvf_vt) = i_Cpvf_vt
-val Cpvf_vt(extracted1ch_Cpvf_vt, extracted2ch_Cpvf_vt) = ch_Cpvf_vt
-assert(1 == extracted1i_Cpvf_vt)
-assert(2 == extracted2i_Cpvf_vt)
-assert('a' == extracted1ch_Cpvf_vt)
-assert('b' == extracted2ch_Cpvf_vt)
-
-assert(2 == i_Cpvf_vt.a)
-assert('b' == ch_Cpvf_vt.a)
-assert(2 == i_Cpvf_vt.p2)
-assert('b' == ch_Cpvf_vt.p2)
-
-
-val ch_Cpvf_vf = new Cpvf_vf('a', 'b')
-val i_Cpvf_vf = new Cpvf_vf(1, 2)
-val Cpvf_vf(extracted1i_Cpvf_vf, extracted2i_Cpvf_vf) = i_Cpvf_vf
-val Cpvf_vf(extracted1ch_Cpvf_vf, extracted2ch_Cpvf_vf) = ch_Cpvf_vf
-assert(1 == extracted1i_Cpvf_vf)
-assert(2 == extracted2i_Cpvf_vf)
-assert('a' == extracted1ch_Cpvf_vf)
-assert('b' == extracted2ch_Cpvf_vf)
-
-assert(2 == i_Cpvf_vf.a)
-assert('b' == ch_Cpvf_vf.a)
-
-
-val ch_Cpvf_nt = new Cpvf_nt('a', 'b')
-val i_Cpvf_nt = new Cpvf_nt(1, 2)
-val Cpvf_nt(extracted1i_Cpvf_nt, extracted2i_Cpvf_nt) = i_Cpvf_nt
-val Cpvf_nt(extracted1ch_Cpvf_nt, extracted2ch_Cpvf_nt) = ch_Cpvf_nt
-assert(1 == extracted1i_Cpvf_nt)
-assert(2 == extracted2i_Cpvf_nt)
-assert('a' == extracted1ch_Cpvf_nt)
-assert('b' == extracted2ch_Cpvf_nt)
-
-assert(2 == i_Cpvf_nt.a)
-assert('b' == ch_Cpvf_nt.a)
-assert(2 == i_Cpvf_nt.p2)
-assert('b' == ch_Cpvf_nt.p2)
-
-
-val ch_Cpvf_nf = new Cpvf_nf('a', 'b')
-val i_Cpvf_nf = new Cpvf_nf(1, 2)
-val Cpvf_nf(extracted1i_Cpvf_nf, extracted2i_Cpvf_nf) = i_Cpvf_nf
-val Cpvf_nf(extracted1ch_Cpvf_nf, extracted2ch_Cpvf_nf) = ch_Cpvf_nf
-assert(1 == extracted1i_Cpvf_nf)
-assert(2 == extracted2i_Cpvf_nf)
-assert('a' == extracted1ch_Cpvf_nf)
-assert('b' == extracted2ch_Cpvf_nf)
-
-assert(2 == i_Cpvf_nf.a)
-assert('b' == ch_Cpvf_nf.a)
-
-
-val ch_Cvt_pvt = new Cvt_pvt('a', 'b')
-val i_Cvt_pvt = new Cvt_pvt(1, 2)
-val Cvt_pvt(extracted1i_Cvt_pvt, extracted2i_Cvt_pvt) = i_Cvt_pvt
-val Cvt_pvt(extracted1ch_Cvt_pvt, extracted2ch_Cvt_pvt) = ch_Cvt_pvt
-assert(1 == extracted1i_Cvt_pvt)
-assert(2 == extracted2i_Cvt_pvt)
-assert('a' == extracted1ch_Cvt_pvt)
-assert('b' == extracted2ch_Cvt_pvt)
-
-assert(1 == i_Cvt_pvt.`a b`)
-assert('a' == ch_Cvt_pvt.`a b`)
-assert(1 == i_Cvt_pvt.p1)
-assert(2 == i_Cvt_pvt.p2)
-assert('a' == ch_Cvt_pvt.p1)
-assert('b' == ch_Cvt_pvt.p2)
-
-
-val ch_Cvt_pvf = new Cvt_pvf('a', 'b')
-val i_Cvt_pvf = new Cvt_pvf(1, 2)
-val Cvt_pvf(extracted1i_Cvt_pvf, extracted2i_Cvt_pvf) = i_Cvt_pvf
-val Cvt_pvf(extracted1ch_Cvt_pvf, extracted2ch_Cvt_pvf) = ch_Cvt_pvf
-assert(1 == extracted1i_Cvt_pvf)
-assert(2 == extracted2i_Cvt_pvf)
-assert('a' == extracted1ch_Cvt_pvf)
-assert('b' == extracted2ch_Cvt_pvf)
-
-assert(1 == i_Cvt_pvf.`a b`)
-assert('a' == ch_Cvt_pvf.`a b`)
-assert(1 == i_Cvt_pvf.p1)
-assert('a' == ch_Cvt_pvf.p1)
-
-
-val ch_Cvt_vt = new Cvt_vt('a', 'b')
-val i_Cvt_vt = new Cvt_vt(1, 2)
-val Cvt_vt(extracted1i_Cvt_vt, extracted2i_Cvt_vt) = i_Cvt_vt
-val Cvt_vt(extracted1ch_Cvt_vt, extracted2ch_Cvt_vt) = ch_Cvt_vt
-assert(1 == extracted1i_Cvt_vt)
-assert(2 == extracted2i_Cvt_vt)
-assert('a' == extracted1ch_Cvt_vt)
-assert('b' == extracted2ch_Cvt_vt)
-
-assert(1 == i_Cvt_vt.`a b`)
-assert(2 == i_Cvt_vt.a)
-assert('a' == ch_Cvt_vt.`a b`)
-assert('b' == ch_Cvt_vt.a)
-assert(1 == i_Cvt_vt.p1)
-assert(2 == i_Cvt_vt.p2)
-assert('a' == ch_Cvt_vt.p1)
-assert('b' == ch_Cvt_vt.p2)
-
-
-val ch_Cvt_vf = new Cvt_vf('a', 'b')
-val i_Cvt_vf = new Cvt_vf(1, 2)
-val Cvt_vf(extracted1i_Cvt_vf, extracted2i_Cvt_vf) = i_Cvt_vf
-val Cvt_vf(extracted1ch_Cvt_vf, extracted2ch_Cvt_vf) = ch_Cvt_vf
-assert(1 == extracted1i_Cvt_vf)
-assert(2 == extracted2i_Cvt_vf)
-assert('a' == extracted1ch_Cvt_vf)
-assert('b' == extracted2ch_Cvt_vf)
-
-assert(1 == i_Cvt_vf.`a b`)
-assert(2 == i_Cvt_vf.a)
-assert('a' == ch_Cvt_vf.`a b`)
-assert('b' == ch_Cvt_vf.a)
-assert(1 == i_Cvt_vf.p1)
-assert('a' == ch_Cvt_vf.p1)
-
-
-val ch_Cvt_nt = new Cvt_nt('a', 'b')
-val i_Cvt_nt = new Cvt_nt(1, 2)
-val Cvt_nt(extracted1i_Cvt_nt, extracted2i_Cvt_nt) = i_Cvt_nt
-val Cvt_nt(extracted1ch_Cvt_nt, extracted2ch_Cvt_nt) = ch_Cvt_nt
-assert(1 == extracted1i_Cvt_nt)
-assert(2 == extracted2i_Cvt_nt)
-assert('a' == extracted1ch_Cvt_nt)
-assert('b' == extracted2ch_Cvt_nt)
-
-assert(1 == i_Cvt_nt.`a b`)
-assert(2 == i_Cvt_nt.a)
-assert('a' == ch_Cvt_nt.`a b`)
-assert('b' == ch_Cvt_nt.a)
-assert(1 == i_Cvt_nt.p1)
-assert(2 == i_Cvt_nt.p2)
-assert('a' == ch_Cvt_nt.p1)
-assert('b' == ch_Cvt_nt.p2)
-
-
-val ch_Cvt_nf = new Cvt_nf('a', 'b')
-val i_Cvt_nf = new Cvt_nf(1, 2)
-val Cvt_nf(extracted1i_Cvt_nf, extracted2i_Cvt_nf) = i_Cvt_nf
-val Cvt_nf(extracted1ch_Cvt_nf, extracted2ch_Cvt_nf) = ch_Cvt_nf
-assert(1 == extracted1i_Cvt_nf)
-assert(2 == extracted2i_Cvt_nf)
-assert('a' == extracted1ch_Cvt_nf)
-assert('b' == extracted2ch_Cvt_nf)
-
-assert(1 == i_Cvt_nf.`a b`)
-assert(2 == i_Cvt_nf.a)
-assert('a' == ch_Cvt_nf.`a b`)
-assert('b' == ch_Cvt_nf.a)
-assert(1 == i_Cvt_nf.p1)
-assert('a' == ch_Cvt_nf.p1)
-
-
-val ch_Cvf_pvt = new Cvf_pvt('a', 'b')
-val i_Cvf_pvt = new Cvf_pvt(1, 2)
-val Cvf_pvt(extracted1i_Cvf_pvt, extracted2i_Cvf_pvt) = i_Cvf_pvt
-val Cvf_pvt(extracted1ch_Cvf_pvt, extracted2ch_Cvf_pvt) = ch_Cvf_pvt
-assert(1 == extracted1i_Cvf_pvt)
-assert(2 == extracted2i_Cvf_pvt)
-assert('a' == extracted1ch_Cvf_pvt)
-assert('b' == extracted2ch_Cvf_pvt)
-
-assert(1 == i_Cvf_pvt.`a b`)
-assert('a' == ch_Cvf_pvt.`a b`)
-assert(2 == i_Cvf_pvt.p2)
-assert('b' == ch_Cvf_pvt.p2)
-
-
-val ch_Cvf_pvf = new Cvf_pvf('a', 'b')
-val i_Cvf_pvf = new Cvf_pvf(1, 2)
-val Cvf_pvf(extracted1i_Cvf_pvf, extracted2i_Cvf_pvf) = i_Cvf_pvf
-val Cvf_pvf(extracted1ch_Cvf_pvf, extracted2ch_Cvf_pvf) = ch_Cvf_pvf
-assert(1 == extracted1i_Cvf_pvf)
-assert(2 == extracted2i_Cvf_pvf)
-assert('a' == extracted1ch_Cvf_pvf)
-assert('b' == extracted2ch_Cvf_pvf)
-
-assert(1 == i_Cvf_pvf.`a b`)
-assert('a' == ch_Cvf_pvf.`a b`)
-
-
-val ch_Cvf_vt = new Cvf_vt('a', 'b')
-val i_Cvf_vt = new Cvf_vt(1, 2)
-val Cvf_vt(extracted1i_Cvf_vt, extracted2i_Cvf_vt) = i_Cvf_vt
-val Cvf_vt(extracted1ch_Cvf_vt, extracted2ch_Cvf_vt) = ch_Cvf_vt
-assert(1 == extracted1i_Cvf_vt)
-assert(2 == extracted2i_Cvf_vt)
-assert('a' == extracted1ch_Cvf_vt)
-assert('b' == extracted2ch_Cvf_vt)
-
-assert(1 == i_Cvf_vt.`a b`)
-assert(2 == i_Cvf_vt.a)
-assert('a' == ch_Cvf_vt.`a b`)
-assert('b' == ch_Cvf_vt.a)
-assert(2 == i_Cvf_vt.p2)
-assert('b' == ch_Cvf_vt.p2)
-
-
-val ch_Cvf_vf = new Cvf_vf('a', 'b')
-val i_Cvf_vf = new Cvf_vf(1, 2)
-val Cvf_vf(extracted1i_Cvf_vf, extracted2i_Cvf_vf) = i_Cvf_vf
-val Cvf_vf(extracted1ch_Cvf_vf, extracted2ch_Cvf_vf) = ch_Cvf_vf
-assert(1 == extracted1i_Cvf_vf)
-assert(2 == extracted2i_Cvf_vf)
-assert('a' == extracted1ch_Cvf_vf)
-assert('b' == extracted2ch_Cvf_vf)
-
-assert(1 == i_Cvf_vf.`a b`)
-assert(2 == i_Cvf_vf.a)
-assert('a' == ch_Cvf_vf.`a b`)
-assert('b' == ch_Cvf_vf.a)
-
-
-val ch_Cvf_nt = new Cvf_nt('a', 'b')
-val i_Cvf_nt = new Cvf_nt(1, 2)
-val Cvf_nt(extracted1i_Cvf_nt, extracted2i_Cvf_nt) = i_Cvf_nt
-val Cvf_nt(extracted1ch_Cvf_nt, extracted2ch_Cvf_nt) = ch_Cvf_nt
-assert(1 == extracted1i_Cvf_nt)
-assert(2 == extracted2i_Cvf_nt)
-assert('a' == extracted1ch_Cvf_nt)
-assert('b' == extracted2ch_Cvf_nt)
-
-assert(1 == i_Cvf_nt.`a b`)
-assert(2 == i_Cvf_nt.a)
-assert('a' == ch_Cvf_nt.`a b`)
-assert('b' == ch_Cvf_nt.a)
-assert(2 == i_Cvf_nt.p2)
-assert('b' == ch_Cvf_nt.p2)
-
-
-val ch_Cvf_nf = new Cvf_nf('a', 'b')
-val i_Cvf_nf = new Cvf_nf(1, 2)
-val Cvf_nf(extracted1i_Cvf_nf, extracted2i_Cvf_nf) = i_Cvf_nf
-val Cvf_nf(extracted1ch_Cvf_nf, extracted2ch_Cvf_nf) = ch_Cvf_nf
-assert(1 == extracted1i_Cvf_nf)
-assert(2 == extracted2i_Cvf_nf)
-assert('a' == extracted1ch_Cvf_nf)
-assert('b' == extracted2ch_Cvf_nf)
-
-assert(1 == i_Cvf_nf.`a b`)
-assert(2 == i_Cvf_nf.a)
-assert('a' == ch_Cvf_nf.`a b`)
-assert('b' == ch_Cvf_nf.a)
-
-
-val ch_Cnt_pvt = new Cnt_pvt('a', 'b')
-val i_Cnt_pvt = new Cnt_pvt(1, 2)
-val Cnt_pvt(extracted1i_Cnt_pvt, extracted2i_Cnt_pvt) = i_Cnt_pvt
-val Cnt_pvt(extracted1ch_Cnt_pvt, extracted2ch_Cnt_pvt) = ch_Cnt_pvt
-assert(1 == extracted1i_Cnt_pvt)
-assert(2 == extracted2i_Cnt_pvt)
-assert('a' == extracted1ch_Cnt_pvt)
-assert('b' == extracted2ch_Cnt_pvt)
-
-assert(1 == i_Cnt_pvt.`a b`)
-assert('a' == ch_Cnt_pvt.`a b`)
-assert(1 == i_Cnt_pvt.p1)
-assert(2 == i_Cnt_pvt.p2)
-assert('a' == ch_Cnt_pvt.p1)
-assert('b' == ch_Cnt_pvt.p2)
-
-
-val ch_Cnt_pvf = new Cnt_pvf('a', 'b')
-val i_Cnt_pvf = new Cnt_pvf(1, 2)
-val Cnt_pvf(extracted1i_Cnt_pvf, extracted2i_Cnt_pvf) = i_Cnt_pvf
-val Cnt_pvf(extracted1ch_Cnt_pvf, extracted2ch_Cnt_pvf) = ch_Cnt_pvf
-assert(1 == extracted1i_Cnt_pvf)
-assert(2 == extracted2i_Cnt_pvf)
-assert('a' == extracted1ch_Cnt_pvf)
-assert('b' == extracted2ch_Cnt_pvf)
-
-assert(1 == i_Cnt_pvf.`a b`)
-assert('a' == ch_Cnt_pvf.`a b`)
-assert(1 == i_Cnt_pvf.p1)
-assert('a' == ch_Cnt_pvf.p1)
-
-
-val ch_Cnt_vt = new Cnt_vt('a', 'b')
-val i_Cnt_vt = new Cnt_vt(1, 2)
-val Cnt_vt(extracted1i_Cnt_vt, extracted2i_Cnt_vt) = i_Cnt_vt
-val Cnt_vt(extracted1ch_Cnt_vt, extracted2ch_Cnt_vt) = ch_Cnt_vt
-assert(1 == extracted1i_Cnt_vt)
-assert(2 == extracted2i_Cnt_vt)
-assert('a' == extracted1ch_Cnt_vt)
-assert('b' == extracted2ch_Cnt_vt)
-
-assert(1 == i_Cnt_vt.`a b`)
-assert(2 == i_Cnt_vt.a)
-assert('a' == ch_Cnt_vt.`a b`)
-assert('b' == ch_Cnt_vt.a)
-assert(1 == i_Cnt_vt.p1)
-assert(2 == i_Cnt_vt.p2)
-assert('a' == ch_Cnt_vt.p1)
-assert('b' == ch_Cnt_vt.p2)
-
-
-val ch_Cnt_vf = new Cnt_vf('a', 'b')
-val i_Cnt_vf = new Cnt_vf(1, 2)
-val Cnt_vf(extracted1i_Cnt_vf, extracted2i_Cnt_vf) = i_Cnt_vf
-val Cnt_vf(extracted1ch_Cnt_vf, extracted2ch_Cnt_vf) = ch_Cnt_vf
-assert(1 == extracted1i_Cnt_vf)
-assert(2 == extracted2i_Cnt_vf)
-assert('a' == extracted1ch_Cnt_vf)
-assert('b' == extracted2ch_Cnt_vf)
-
-assert(1 == i_Cnt_vf.`a b`)
-assert(2 == i_Cnt_vf.a)
-assert('a' == ch_Cnt_vf.`a b`)
-assert('b' == ch_Cnt_vf.a)
-assert(1 == i_Cnt_vf.p1)
-assert('a' == ch_Cnt_vf.p1)
-
-
-val ch_Cnt_nt = new Cnt_nt('a', 'b')
-val i_Cnt_nt = new Cnt_nt(1, 2)
-val Cnt_nt(extracted1i_Cnt_nt, extracted2i_Cnt_nt) = i_Cnt_nt
-val Cnt_nt(extracted1ch_Cnt_nt, extracted2ch_Cnt_nt) = ch_Cnt_nt
-assert(1 == extracted1i_Cnt_nt)
-assert(2 == extracted2i_Cnt_nt)
-assert('a' == extracted1ch_Cnt_nt)
-assert('b' == extracted2ch_Cnt_nt)
-
-assert(1 == i_Cnt_nt.`a b`)
-assert(2 == i_Cnt_nt.a)
-assert('a' == ch_Cnt_nt.`a b`)
-assert('b' == ch_Cnt_nt.a)
-assert(1 == i_Cnt_nt.p1)
-assert(2 == i_Cnt_nt.p2)
-assert('a' == ch_Cnt_nt.p1)
-assert('b' == ch_Cnt_nt.p2)
-
-
-val ch_Cnt_nf = new Cnt_nf('a', 'b')
-val i_Cnt_nf = new Cnt_nf(1, 2)
-val Cnt_nf(extracted1i_Cnt_nf, extracted2i_Cnt_nf) = i_Cnt_nf
-val Cnt_nf(extracted1ch_Cnt_nf, extracted2ch_Cnt_nf) = ch_Cnt_nf
-assert(1 == extracted1i_Cnt_nf)
-assert(2 == extracted2i_Cnt_nf)
-assert('a' == extracted1ch_Cnt_nf)
-assert('b' == extracted2ch_Cnt_nf)
-
-assert(1 == i_Cnt_nf.`a b`)
-assert(2 == i_Cnt_nf.a)
-assert('a' == ch_Cnt_nf.`a b`)
-assert('b' == ch_Cnt_nf.a)
-assert(1 == i_Cnt_nf.p1)
-assert('a' == ch_Cnt_nf.p1)
-
-
-val ch_Cnf_pvt = new Cnf_pvt('a', 'b')
-val i_Cnf_pvt = new Cnf_pvt(1, 2)
-val Cnf_pvt(extracted1i_Cnf_pvt, extracted2i_Cnf_pvt) = i_Cnf_pvt
-val Cnf_pvt(extracted1ch_Cnf_pvt, extracted2ch_Cnf_pvt) = ch_Cnf_pvt
-assert(1 == extracted1i_Cnf_pvt)
-assert(2 == extracted2i_Cnf_pvt)
-assert('a' == extracted1ch_Cnf_pvt)
-assert('b' == extracted2ch_Cnf_pvt)
-
-assert(1 == i_Cnf_pvt.`a b`)
-assert('a' == ch_Cnf_pvt.`a b`)
-assert(2 == i_Cnf_pvt.p2)
-assert('b' == ch_Cnf_pvt.p2)
-
-
-val ch_Cnf_pvf = new Cnf_pvf('a', 'b')
-val i_Cnf_pvf = new Cnf_pvf(1, 2)
-val Cnf_pvf(extracted1i_Cnf_pvf, extracted2i_Cnf_pvf) = i_Cnf_pvf
-val Cnf_pvf(extracted1ch_Cnf_pvf, extracted2ch_Cnf_pvf) = ch_Cnf_pvf
-assert(1 == extracted1i_Cnf_pvf)
-assert(2 == extracted2i_Cnf_pvf)
-assert('a' == extracted1ch_Cnf_pvf)
-assert('b' == extracted2ch_Cnf_pvf)
-
-assert(1 == i_Cnf_pvf.`a b`)
-assert('a' == ch_Cnf_pvf.`a b`)
-
-
-val ch_Cnf_vt = new Cnf_vt('a', 'b')
-val i_Cnf_vt = new Cnf_vt(1, 2)
-val Cnf_vt(extracted1i_Cnf_vt, extracted2i_Cnf_vt) = i_Cnf_vt
-val Cnf_vt(extracted1ch_Cnf_vt, extracted2ch_Cnf_vt) = ch_Cnf_vt
-assert(1 == extracted1i_Cnf_vt)
-assert(2 == extracted2i_Cnf_vt)
-assert('a' == extracted1ch_Cnf_vt)
-assert('b' == extracted2ch_Cnf_vt)
-
-assert(1 == i_Cnf_vt.`a b`)
-assert(2 == i_Cnf_vt.a)
-assert('a' == ch_Cnf_vt.`a b`)
-assert('b' == ch_Cnf_vt.a)
-assert(2 == i_Cnf_vt.p2)
-assert('b' == ch_Cnf_vt.p2)
-
-
-val ch_Cnf_vf = new Cnf_vf('a', 'b')
-val i_Cnf_vf = new Cnf_vf(1, 2)
-val Cnf_vf(extracted1i_Cnf_vf, extracted2i_Cnf_vf) = i_Cnf_vf
-val Cnf_vf(extracted1ch_Cnf_vf, extracted2ch_Cnf_vf) = ch_Cnf_vf
-assert(1 == extracted1i_Cnf_vf)
-assert(2 == extracted2i_Cnf_vf)
-assert('a' == extracted1ch_Cnf_vf)
-assert('b' == extracted2ch_Cnf_vf)
-
-assert(1 == i_Cnf_vf.`a b`)
-assert(2 == i_Cnf_vf.a)
-assert('a' == ch_Cnf_vf.`a b`)
-assert('b' == ch_Cnf_vf.a)
-
-
-val ch_Cnf_nt = new Cnf_nt('a', 'b')
-val i_Cnf_nt = new Cnf_nt(1, 2)
-val Cnf_nt(extracted1i_Cnf_nt, extracted2i_Cnf_nt) = i_Cnf_nt
-val Cnf_nt(extracted1ch_Cnf_nt, extracted2ch_Cnf_nt) = ch_Cnf_nt
-assert(1 == extracted1i_Cnf_nt)
-assert(2 == extracted2i_Cnf_nt)
-assert('a' == extracted1ch_Cnf_nt)
-assert('b' == extracted2ch_Cnf_nt)
-
-assert(1 == i_Cnf_nt.`a b`)
-assert(2 == i_Cnf_nt.a)
-assert('a' == ch_Cnf_nt.`a b`)
-assert('b' == ch_Cnf_nt.a)
-assert(2 == i_Cnf_nt.p2)
-assert('b' == ch_Cnf_nt.p2)
-
-
-val ch_Cnf_nf = new Cnf_nf('a', 'b')
-val i_Cnf_nf = new Cnf_nf(1, 2)
-val Cnf_nf(extracted1i_Cnf_nf, extracted2i_Cnf_nf) = i_Cnf_nf
-val Cnf_nf(extracted1ch_Cnf_nf, extracted2ch_Cnf_nf) = ch_Cnf_nf
-assert(1 == extracted1i_Cnf_nf)
-assert(2 == extracted2i_Cnf_nf)
-assert('a' == extracted1ch_Cnf_nf)
-assert('b' == extracted2ch_Cnf_nf)
-
-assert(1 == i_Cnf_nf.`a b`)
-assert(2 == i_Cnf_nf.a)
-assert('a' == ch_Cnf_nf.`a b`)
-assert('b' == ch_Cnf_nf.a)
-
-
-val ch_Rpvt_pvt = new Rpvt_pvt('a', 'b')
-val i_Rpvt_pvt = new Rpvt_pvt(1, 2)
-assert(1 == i_Rpvt_pvt.p1)
-assert(2 == i_Rpvt_pvt.p2)
-assert('a' == ch_Rpvt_pvt.p1)
-assert('b' == ch_Rpvt_pvt.p2)
-
-
-val ch_Rpvt_pvf = new Rpvt_pvf('a', 'b')
-val i_Rpvt_pvf = new Rpvt_pvf(1, 2)
-assert(1 == i_Rpvt_pvf.p1)
-assert('a' == ch_Rpvt_pvf.p1)
-
-
-val ch_Rpvt_vt = new Rpvt_vt('a', 'b')
-val i_Rpvt_vt = new Rpvt_vt(1, 2)
-assert(2 == i_Rpvt_vt.a)
-assert('b' == ch_Rpvt_vt.a)
-assert(1 == i_Rpvt_vt.p1)
-assert(2 == i_Rpvt_vt.p2)
-assert('a' == ch_Rpvt_vt.p1)
-assert('b' == ch_Rpvt_vt.p2)
-
-
-val ch_Rpvt_vf = new Rpvt_vf('a', 'b')
-val i_Rpvt_vf = new Rpvt_vf(1, 2)
-assert(2 == i_Rpvt_vf.a)
-assert('b' == ch_Rpvt_vf.a)
-assert(1 == i_Rpvt_vf.p1)
-assert('a' == ch_Rpvt_vf.p1)
-
-
-val ch_Rpvt_nt = new Rpvt_nt('a', 'b')
-val i_Rpvt_nt = new Rpvt_nt(1, 2)
-assert(1 == i_Rpvt_nt.p1)
-assert(2 == i_Rpvt_nt.p2)
-assert('a' == ch_Rpvt_nt.p1)
-assert('b' == ch_Rpvt_nt.p2)
-
-
-val ch_Rpvt_nf = new Rpvt_nf('a', 'b')
-val i_Rpvt_nf = new Rpvt_nf(1, 2)
-assert(1 == i_Rpvt_nf.p1)
-assert('a' == ch_Rpvt_nf.p1)
-
-
-val ch_Rpvf_pvt = new Rpvf_pvt('a', 'b')
-val i_Rpvf_pvt = new Rpvf_pvt(1, 2)
-assert(2 == i_Rpvf_pvt.p2)
-assert('b' == ch_Rpvf_pvt.p2)
-
-
-val ch_Rpvf_pvf = new Rpvf_pvf('a', 'b')
-val i_Rpvf_pvf = new Rpvf_pvf(1, 2)
-
-
-val ch_Rpvf_vt = new Rpvf_vt('a', 'b')
-val i_Rpvf_vt = new Rpvf_vt(1, 2)
-assert(2 == i_Rpvf_vt.a)
-assert('b' == ch_Rpvf_vt.a)
-assert(2 == i_Rpvf_vt.p2)
-assert('b' == ch_Rpvf_vt.p2)
-
-
-val ch_Rpvf_vf = new Rpvf_vf('a', 'b')
-val i_Rpvf_vf = new Rpvf_vf(1, 2)
-assert(2 == i_Rpvf_vf.a)
-assert('b' == ch_Rpvf_vf.a)
-
-
-val ch_Rpvf_nt = new Rpvf_nt('a', 'b')
-val i_Rpvf_nt = new Rpvf_nt(1, 2)
-assert(2 == i_Rpvf_nt.p2)
-assert('b' == ch_Rpvf_nt.p2)
-
-
-val ch_Rpvf_nf = new Rpvf_nf('a', 'b')
-val i_Rpvf_nf = new Rpvf_nf(1, 2)
-
-
-val ch_Rvt_pvt = new Rvt_pvt('a', 'b')
-val i_Rvt_pvt = new Rvt_pvt(1, 2)
-assert(1 == i_Rvt_pvt.`a b`)
-assert('a' == ch_Rvt_pvt.`a b`)
-assert(1 == i_Rvt_pvt.p1)
-assert(2 == i_Rvt_pvt.p2)
-assert('a' == ch_Rvt_pvt.p1)
-assert('b' == ch_Rvt_pvt.p2)
-
-
-val ch_Rvt_pvf = new Rvt_pvf('a', 'b')
-val i_Rvt_pvf = new Rvt_pvf(1, 2)
-assert(1 == i_Rvt_pvf.`a b`)
-assert('a' == ch_Rvt_pvf.`a b`)
-assert(1 == i_Rvt_pvf.p1)
-assert('a' == ch_Rvt_pvf.p1)
-
-
-val ch_Rvt_vt = new Rvt_vt('a', 'b')
-val i_Rvt_vt = new Rvt_vt(1, 2)
-assert(1 == i_Rvt_vt.`a b`)
-assert(2 == i_Rvt_vt.a)
-assert('a' == ch_Rvt_vt.`a b`)
-assert('b' == ch_Rvt_vt.a)
-assert(1 == i_Rvt_vt.p1)
-assert(2 == i_Rvt_vt.p2)
-assert('a' == ch_Rvt_vt.p1)
-assert('b' == ch_Rvt_vt.p2)
-
-
-val ch_Rvt_vf = new Rvt_vf('a', 'b')
-val i_Rvt_vf = new Rvt_vf(1, 2)
-assert(1 == i_Rvt_vf.`a b`)
-assert(2 == i_Rvt_vf.a)
-assert('a' == ch_Rvt_vf.`a b`)
-assert('b' == ch_Rvt_vf.a)
-assert(1 == i_Rvt_vf.p1)
-assert('a' == ch_Rvt_vf.p1)
-
-
-val ch_Rvt_nt = new Rvt_nt('a', 'b')
-val i_Rvt_nt = new Rvt_nt(1, 2)
-assert(1 == i_Rvt_nt.`a b`)
-assert('a' == ch_Rvt_nt.`a b`)
-assert(1 == i_Rvt_nt.p1)
-assert(2 == i_Rvt_nt.p2)
-assert('a' == ch_Rvt_nt.p1)
-assert('b' == ch_Rvt_nt.p2)
-
-
-val ch_Rvt_nf = new Rvt_nf('a', 'b')
-val i_Rvt_nf = new Rvt_nf(1, 2)
-assert(1 == i_Rvt_nf.`a b`)
-assert('a' == ch_Rvt_nf.`a b`)
-assert(1 == i_Rvt_nf.p1)
-assert('a' == ch_Rvt_nf.p1)
-
-
-val ch_Rvf_pvt = new Rvf_pvt('a', 'b')
-val i_Rvf_pvt = new Rvf_pvt(1, 2)
-assert(1 == i_Rvf_pvt.`a b`)
-assert('a' == ch_Rvf_pvt.`a b`)
-assert(2 == i_Rvf_pvt.p2)
-assert('b' == ch_Rvf_pvt.p2)
-
-
-val ch_Rvf_pvf = new Rvf_pvf('a', 'b')
-val i_Rvf_pvf = new Rvf_pvf(1, 2)
-assert(1 == i_Rvf_pvf.`a b`)
-assert('a' == ch_Rvf_pvf.`a b`)
-
-
-val ch_Rvf_vt = new Rvf_vt('a', 'b')
-val i_Rvf_vt = new Rvf_vt(1, 2)
-assert(1 == i_Rvf_vt.`a b`)
-assert(2 == i_Rvf_vt.a)
-assert('a' == ch_Rvf_vt.`a b`)
-assert('b' == ch_Rvf_vt.a)
-assert(2 == i_Rvf_vt.p2)
-assert('b' == ch_Rvf_vt.p2)
-
-
-val ch_Rvf_vf = new Rvf_vf('a', 'b')
-val i_Rvf_vf = new Rvf_vf(1, 2)
-assert(1 == i_Rvf_vf.`a b`)
-assert(2 == i_Rvf_vf.a)
-assert('a' == ch_Rvf_vf.`a b`)
-assert('b' == ch_Rvf_vf.a)
-
-
-val ch_Rvf_nt = new Rvf_nt('a', 'b')
-val i_Rvf_nt = new Rvf_nt(1, 2)
-assert(1 == i_Rvf_nt.`a b`)
-assert('a' == ch_Rvf_nt.`a b`)
-assert(2 == i_Rvf_nt.p2)
-assert('b' == ch_Rvf_nt.p2)
-
-
-val ch_Rvf_nf = new Rvf_nf('a', 'b')
-val i_Rvf_nf = new Rvf_nf(1, 2)
-assert(1 == i_Rvf_nf.`a b`)
-assert('a' == ch_Rvf_nf.`a b`)
-
-
-val ch_Rnt_pvt = new Rnt_pvt('a', 'b')
-val i_Rnt_pvt = new Rnt_pvt(1, 2)
-assert(1 == i_Rnt_pvt.p1)
-assert(2 == i_Rnt_pvt.p2)
-assert('a' == ch_Rnt_pvt.p1)
-assert('b' == ch_Rnt_pvt.p2)
-
-
-val ch_Rnt_pvf = new Rnt_pvf('a', 'b')
-val i_Rnt_pvf = new Rnt_pvf(1, 2)
-assert(1 == i_Rnt_pvf.p1)
-assert('a' == ch_Rnt_pvf.p1)
-
-
-val ch_Rnt_vt = new Rnt_vt('a', 'b')
-val i_Rnt_vt = new Rnt_vt(1, 2)
-assert(2 == i_Rnt_vt.a)
-assert('b' == ch_Rnt_vt.a)
-assert(1 == i_Rnt_vt.p1)
-assert(2 == i_Rnt_vt.p2)
-assert('a' == ch_Rnt_vt.p1)
-assert('b' == ch_Rnt_vt.p2)
-
-
-val ch_Rnt_vf = new Rnt_vf('a', 'b')
-val i_Rnt_vf = new Rnt_vf(1, 2)
-assert(2 == i_Rnt_vf.a)
-assert('b' == ch_Rnt_vf.a)
-assert(1 == i_Rnt_vf.p1)
-assert('a' == ch_Rnt_vf.p1)
-
-
-val ch_Rnt_nt = new Rnt_nt('a', 'b')
-val i_Rnt_nt = new Rnt_nt(1, 2)
-assert(1 == i_Rnt_nt.p1)
-assert(2 == i_Rnt_nt.p2)
-assert('a' == ch_Rnt_nt.p1)
-assert('b' == ch_Rnt_nt.p2)
-
-
-val ch_Rnt_nf = new Rnt_nf('a', 'b')
-val i_Rnt_nf = new Rnt_nf(1, 2)
-assert(1 == i_Rnt_nf.p1)
-assert('a' == ch_Rnt_nf.p1)
-
-
-val ch_Rnf_pvt = new Rnf_pvt('a', 'b')
-val i_Rnf_pvt = new Rnf_pvt(1, 2)
-assert(2 == i_Rnf_pvt.p2)
-assert('b' == ch_Rnf_pvt.p2)
-
-
-val ch_Rnf_pvf = new Rnf_pvf('a', 'b')
-val i_Rnf_pvf = new Rnf_pvf(1, 2)
-
-
-val ch_Rnf_vt = new Rnf_vt('a', 'b')
-val i_Rnf_vt = new Rnf_vt(1, 2)
-assert(2 == i_Rnf_vt.a)
-assert('b' == ch_Rnf_vt.a)
-assert(2 == i_Rnf_vt.p2)
-assert('b' == ch_Rnf_vt.p2)
-
-
-val ch_Rnf_vf = new Rnf_vf('a', 'b')
-val i_Rnf_vf = new Rnf_vf(1, 2)
-assert(2 == i_Rnf_vf.a)
-assert('b' == ch_Rnf_vf.a)
-
-
-val ch_Rnf_nt = new Rnf_nt('a', 'b')
-val i_Rnf_nt = new Rnf_nt(1, 2)
-assert(2 == i_Rnf_nt.p2)
-assert('b' == ch_Rnf_nt.p2)
-
-
-val ch_Rnf_nf = new Rnf_nf('a', 'b')
-val i_Rnf_nf = new Rnf_nf(1, 2)
+val ch_Cpv_pv = new Cpv_pv('a', 'b')
+val i_Cpv_pv = new Cpv_pv(1, 2)
+val Cpv_pv(extracted1i_Cpv_pv, extracted2i_Cpv_pv) = i_Cpv_pv
+val Cpv_pv(extracted1ch_Cpv_pv, extracted2ch_Cpv_pv) = ch_Cpv_pv
+assert(1 == extracted1i_Cpv_pv)
+assert(2 == extracted2i_Cpv_pv)
+assert('a' == extracted1ch_Cpv_pv)
+assert('b' == extracted2ch_Cpv_pv)
+
+assert(1 == i_Cpv_pv.p1)
+assert(2 == i_Cpv_pv.p2)
+assert('a' == ch_Cpv_pv.p1)
+assert('b' == ch_Cpv_pv.p2)
+
+
+val ch_Cpv_v = new Cpv_v('a', 'b')
+val i_Cpv_v = new Cpv_v(1, 2)
+val Cpv_v(extracted1i_Cpv_v, extracted2i_Cpv_v) = i_Cpv_v
+val Cpv_v(extracted1ch_Cpv_v, extracted2ch_Cpv_v) = ch_Cpv_v
+assert(1 == extracted1i_Cpv_v)
+assert(2 == extracted2i_Cpv_v)
+assert('a' == extracted1ch_Cpv_v)
+assert('b' == extracted2ch_Cpv_v)
+
+assert(2 == i_Cpv_v.a)
+assert('b' == ch_Cpv_v.a)
+assert(1 == i_Cpv_v.p1)
+assert(2 == i_Cpv_v.p2)
+assert('a' == ch_Cpv_v.p1)
+assert('b' == ch_Cpv_v.p2)
+
+
+val ch_Cpv_n = new Cpv_n('a', 'b')
+val i_Cpv_n = new Cpv_n(1, 2)
+val Cpv_n(extracted1i_Cpv_n, extracted2i_Cpv_n) = i_Cpv_n
+val Cpv_n(extracted1ch_Cpv_n, extracted2ch_Cpv_n) = ch_Cpv_n
+assert(1 == extracted1i_Cpv_n)
+assert(2 == extracted2i_Cpv_n)
+assert('a' == extracted1ch_Cpv_n)
+assert('b' == extracted2ch_Cpv_n)
+
+assert(2 == i_Cpv_n.a)
+assert('b' == ch_Cpv_n.a)
+assert(1 == i_Cpv_n.p1)
+assert(2 == i_Cpv_n.p2)
+assert('a' == ch_Cpv_n.p1)
+assert('b' == ch_Cpv_n.p2)
+
+
+val ch_Cv_pv = new Cv_pv('a', 'b')
+val i_Cv_pv = new Cv_pv(1, 2)
+val Cv_pv(extracted1i_Cv_pv, extracted2i_Cv_pv) = i_Cv_pv
+val Cv_pv(extracted1ch_Cv_pv, extracted2ch_Cv_pv) = ch_Cv_pv
+assert(1 == extracted1i_Cv_pv)
+assert(2 == extracted2i_Cv_pv)
+assert('a' == extracted1ch_Cv_pv)
+assert('b' == extracted2ch_Cv_pv)
+
+assert(1 == i_Cv_pv.`a b`)
+assert('a' == ch_Cv_pv.`a b`)
+assert(1 == i_Cv_pv.p1)
+assert(2 == i_Cv_pv.p2)
+assert('a' == ch_Cv_pv.p1)
+assert('b' == ch_Cv_pv.p2)
+
+
+val ch_Cv_v = new Cv_v('a', 'b')
+val i_Cv_v = new Cv_v(1, 2)
+val Cv_v(extracted1i_Cv_v, extracted2i_Cv_v) = i_Cv_v
+val Cv_v(extracted1ch_Cv_v, extracted2ch_Cv_v) = ch_Cv_v
+assert(1 == extracted1i_Cv_v)
+assert(2 == extracted2i_Cv_v)
+assert('a' == extracted1ch_Cv_v)
+assert('b' == extracted2ch_Cv_v)
+
+assert(1 == i_Cv_v.`a b`)
+assert(2 == i_Cv_v.a)
+assert('a' == ch_Cv_v.`a b`)
+assert('b' == ch_Cv_v.a)
+assert(1 == i_Cv_v.p1)
+assert(2 == i_Cv_v.p2)
+assert('a' == ch_Cv_v.p1)
+assert('b' == ch_Cv_v.p2)
+
+
+val ch_Cv_n = new Cv_n('a', 'b')
+val i_Cv_n = new Cv_n(1, 2)
+val Cv_n(extracted1i_Cv_n, extracted2i_Cv_n) = i_Cv_n
+val Cv_n(extracted1ch_Cv_n, extracted2ch_Cv_n) = ch_Cv_n
+assert(1 == extracted1i_Cv_n)
+assert(2 == extracted2i_Cv_n)
+assert('a' == extracted1ch_Cv_n)
+assert('b' == extracted2ch_Cv_n)
+
+assert(1 == i_Cv_n.`a b`)
+assert(2 == i_Cv_n.a)
+assert('a' == ch_Cv_n.`a b`)
+assert('b' == ch_Cv_n.a)
+assert(1 == i_Cv_n.p1)
+assert(2 == i_Cv_n.p2)
+assert('a' == ch_Cv_n.p1)
+assert('b' == ch_Cv_n.p2)
+
+
+val ch_Cn_pv = new Cn_pv('a', 'b')
+val i_Cn_pv = new Cn_pv(1, 2)
+val Cn_pv(extracted1i_Cn_pv, extracted2i_Cn_pv) = i_Cn_pv
+val Cn_pv(extracted1ch_Cn_pv, extracted2ch_Cn_pv) = ch_Cn_pv
+assert(1 == extracted1i_Cn_pv)
+assert(2 == extracted2i_Cn_pv)
+assert('a' == extracted1ch_Cn_pv)
+assert('b' == extracted2ch_Cn_pv)
+
+assert(1 == i_Cn_pv.`a b`)
+assert('a' == ch_Cn_pv.`a b`)
+assert(1 == i_Cn_pv.p1)
+assert(2 == i_Cn_pv.p2)
+assert('a' == ch_Cn_pv.p1)
+assert('b' == ch_Cn_pv.p2)
+
+
+val ch_Cn_v = new Cn_v('a', 'b')
+val i_Cn_v = new Cn_v(1, 2)
+val Cn_v(extracted1i_Cn_v, extracted2i_Cn_v) = i_Cn_v
+val Cn_v(extracted1ch_Cn_v, extracted2ch_Cn_v) = ch_Cn_v
+assert(1 == extracted1i_Cn_v)
+assert(2 == extracted2i_Cn_v)
+assert('a' == extracted1ch_Cn_v)
+assert('b' == extracted2ch_Cn_v)
+
+assert(1 == i_Cn_v.`a b`)
+assert(2 == i_Cn_v.a)
+assert('a' == ch_Cn_v.`a b`)
+assert('b' == ch_Cn_v.a)
+assert(1 == i_Cn_v.p1)
+assert(2 == i_Cn_v.p2)
+assert('a' == ch_Cn_v.p1)
+assert('b' == ch_Cn_v.p2)
+
+
+val ch_Cn_n = new Cn_n('a', 'b')
+val i_Cn_n = new Cn_n(1, 2)
+val Cn_n(extracted1i_Cn_n, extracted2i_Cn_n) = i_Cn_n
+val Cn_n(extracted1ch_Cn_n, extracted2ch_Cn_n) = ch_Cn_n
+assert(1 == extracted1i_Cn_n)
+assert(2 == extracted2i_Cn_n)
+assert('a' == extracted1ch_Cn_n)
+assert('b' == extracted2ch_Cn_n)
+
+assert(1 == i_Cn_n.`a b`)
+assert(2 == i_Cn_n.a)
+assert('a' == ch_Cn_n.`a b`)
+assert('b' == ch_Cn_n.a)
+assert(1 == i_Cn_n.p1)
+assert(2 == i_Cn_n.p2)
+assert('a' == ch_Cn_n.p1)
+assert('b' == ch_Cn_n.p2)
+
+
+val ch_Rpv_pv = new Rpv_pv('a', 'b')
+val i_Rpv_pv = new Rpv_pv(1, 2)
+assert(1 == i_Rpv_pv.p1)
+assert(2 == i_Rpv_pv.p2)
+assert('a' == ch_Rpv_pv.p1)
+assert('b' == ch_Rpv_pv.p2)
+
+
+val ch_Rpv_v = new Rpv_v('a', 'b')
+val i_Rpv_v = new Rpv_v(1, 2)
+assert(2 == i_Rpv_v.a)
+assert('b' == ch_Rpv_v.a)
+assert(1 == i_Rpv_v.p1)
+assert(2 == i_Rpv_v.p2)
+assert('a' == ch_Rpv_v.p1)
+assert('b' == ch_Rpv_v.p2)
+
+
+val ch_Rpv_n = new Rpv_n('a', 'b')
+val i_Rpv_n = new Rpv_n(1, 2)
+assert(1 == i_Rpv_n.p1)
+assert(2 == i_Rpv_n.p2)
+assert('a' == ch_Rpv_n.p1)
+assert('b' == ch_Rpv_n.p2)
+
+
+val ch_Rv_pv = new Rv_pv('a', 'b')
+val i_Rv_pv = new Rv_pv(1, 2)
+assert(1 == i_Rv_pv.`a b`)
+assert('a' == ch_Rv_pv.`a b`)
+assert(1 == i_Rv_pv.p1)
+assert(2 == i_Rv_pv.p2)
+assert('a' == ch_Rv_pv.p1)
+assert('b' == ch_Rv_pv.p2)
+
+
+val ch_Rv_v = new Rv_v('a', 'b')
+val i_Rv_v = new Rv_v(1, 2)
+assert(1 == i_Rv_v.`a b`)
+assert(2 == i_Rv_v.a)
+assert('a' == ch_Rv_v.`a b`)
+assert('b' == ch_Rv_v.a)
+assert(1 == i_Rv_v.p1)
+assert(2 == i_Rv_v.p2)
+assert('a' == ch_Rv_v.p1)
+assert('b' == ch_Rv_v.p2)
+
+
+val ch_Rv_n = new Rv_n('a', 'b')
+val i_Rv_n = new Rv_n(1, 2)
+assert(1 == i_Rv_n.`a b`)
+assert('a' == ch_Rv_n.`a b`)
+assert(1 == i_Rv_n.p1)
+assert(2 == i_Rv_n.p2)
+assert('a' == ch_Rv_n.p1)
+assert('b' == ch_Rv_n.p2)
+
+
+val ch_Rn_pv = new Rn_pv('a', 'b')
+val i_Rn_pv = new Rn_pv(1, 2)
+assert(1 == i_Rn_pv.p1)
+assert(2 == i_Rn_pv.p2)
+assert('a' == ch_Rn_pv.p1)
+assert('b' == ch_Rn_pv.p2)
+
+
+val ch_Rn_v = new Rn_v('a', 'b')
+val i_Rn_v = new Rn_v(1, 2)
+assert(2 == i_Rn_v.a)
+assert('b' == ch_Rn_v.a)
+assert(1 == i_Rn_v.p1)
+assert(2 == i_Rn_v.p2)
+assert('a' == ch_Rn_v.p1)
+assert('b' == ch_Rn_v.p2)
+
+
+val ch_Rn_n = new Rn_n('a', 'b')
+val i_Rn_n = new Rn_n(1, 2)
+assert(1 == i_Rn_n.p1)
+assert(2 == i_Rn_n.p2)
+assert('a' == ch_Rn_n.p1)
+assert('b' == ch_Rn_n.p2)
 
 
 }}
diff --git a/test/files/run/t8831_many/Tests_2.scala b/test/files/run/t8831_many/Tests_2.scala
index 65ff1f0bbab2..d496b4f5ebe7 100644
--- a/test/files/run/t8831_many/Tests_2.scala
+++ b/test/files/run/t8831_many/Tests_2.scala
@@ -1,831 +1,246 @@
 object Test extends App {
 
-val ch_Cpvt_pvt = new Cpvt_pvt('a', 'b')
-val i_Cpvt_pvt = new Cpvt_pvt(1, 2)
-val Cpvt_pvt(extracted1i_Cpvt_pvt, extracted2i_Cpvt_pvt) = i_Cpvt_pvt
-val Cpvt_pvt(extracted1ch_Cpvt_pvt, extracted2ch_Cpvt_pvt) = ch_Cpvt_pvt
-assert(1 == extracted1i_Cpvt_pvt)
-assert(2 == extracted2i_Cpvt_pvt)
-assert('a' == extracted1ch_Cpvt_pvt)
-assert('b' == extracted2ch_Cpvt_pvt)
-
-assert(1 == i_Cpvt_pvt.p1)
-assert(2 == i_Cpvt_pvt.p2)
-assert('a' == ch_Cpvt_pvt.p1)
-assert('b' == ch_Cpvt_pvt.p2)
-
-
-val ch_Cpvt_pvf = new Cpvt_pvf('a', 'b')
-val i_Cpvt_pvf = new Cpvt_pvf(1, 2)
-val Cpvt_pvf(extracted1i_Cpvt_pvf, extracted2i_Cpvt_pvf) = i_Cpvt_pvf
-val Cpvt_pvf(extracted1ch_Cpvt_pvf, extracted2ch_Cpvt_pvf) = ch_Cpvt_pvf
-assert(1 == extracted1i_Cpvt_pvf)
-assert(2 == extracted2i_Cpvt_pvf)
-assert('a' == extracted1ch_Cpvt_pvf)
-assert('b' == extracted2ch_Cpvt_pvf)
-
-assert(1 == i_Cpvt_pvf.p1)
-assert('a' == ch_Cpvt_pvf.p1)
-
-
-val ch_Cpvt_vt = new Cpvt_vt('a', 'b')
-val i_Cpvt_vt = new Cpvt_vt(1, 2)
-val Cpvt_vt(extracted1i_Cpvt_vt, extracted2i_Cpvt_vt) = i_Cpvt_vt
-val Cpvt_vt(extracted1ch_Cpvt_vt, extracted2ch_Cpvt_vt) = ch_Cpvt_vt
-assert(1 == extracted1i_Cpvt_vt)
-assert(2 == extracted2i_Cpvt_vt)
-assert('a' == extracted1ch_Cpvt_vt)
-assert('b' == extracted2ch_Cpvt_vt)
-
-assert(2 == i_Cpvt_vt.a)
-assert('b' == ch_Cpvt_vt.a)
-assert(1 == i_Cpvt_vt.p1)
-assert(2 == i_Cpvt_vt.p2)
-assert('a' == ch_Cpvt_vt.p1)
-assert('b' == ch_Cpvt_vt.p2)
-
-
-val ch_Cpvt_vf = new Cpvt_vf('a', 'b')
-val i_Cpvt_vf = new Cpvt_vf(1, 2)
-val Cpvt_vf(extracted1i_Cpvt_vf, extracted2i_Cpvt_vf) = i_Cpvt_vf
-val Cpvt_vf(extracted1ch_Cpvt_vf, extracted2ch_Cpvt_vf) = ch_Cpvt_vf
-assert(1 == extracted1i_Cpvt_vf)
-assert(2 == extracted2i_Cpvt_vf)
-assert('a' == extracted1ch_Cpvt_vf)
-assert('b' == extracted2ch_Cpvt_vf)
-
-assert(2 == i_Cpvt_vf.a)
-assert('b' == ch_Cpvt_vf.a)
-assert(1 == i_Cpvt_vf.p1)
-assert('a' == ch_Cpvt_vf.p1)
-
-
-val ch_Cpvt_nt = new Cpvt_nt('a', 'b')
-val i_Cpvt_nt = new Cpvt_nt(1, 2)
-val Cpvt_nt(extracted1i_Cpvt_nt, extracted2i_Cpvt_nt) = i_Cpvt_nt
-val Cpvt_nt(extracted1ch_Cpvt_nt, extracted2ch_Cpvt_nt) = ch_Cpvt_nt
-assert(1 == extracted1i_Cpvt_nt)
-assert(2 == extracted2i_Cpvt_nt)
-assert('a' == extracted1ch_Cpvt_nt)
-assert('b' == extracted2ch_Cpvt_nt)
-
-assert(2 == i_Cpvt_nt.a)
-assert('b' == ch_Cpvt_nt.a)
-assert(1 == i_Cpvt_nt.p1)
-assert(2 == i_Cpvt_nt.p2)
-assert('a' == ch_Cpvt_nt.p1)
-assert('b' == ch_Cpvt_nt.p2)
-
-
-val ch_Cpvt_nf = new Cpvt_nf('a', 'b')
-val i_Cpvt_nf = new Cpvt_nf(1, 2)
-val Cpvt_nf(extracted1i_Cpvt_nf, extracted2i_Cpvt_nf) = i_Cpvt_nf
-val Cpvt_nf(extracted1ch_Cpvt_nf, extracted2ch_Cpvt_nf) = ch_Cpvt_nf
-assert(1 == extracted1i_Cpvt_nf)
-assert(2 == extracted2i_Cpvt_nf)
-assert('a' == extracted1ch_Cpvt_nf)
-assert('b' == extracted2ch_Cpvt_nf)
-
-assert(2 == i_Cpvt_nf.a)
-assert('b' == ch_Cpvt_nf.a)
-assert(1 == i_Cpvt_nf.p1)
-assert('a' == ch_Cpvt_nf.p1)
-
-
-val ch_Cpvf_pvt = new Cpvf_pvt('a', 'b')
-val i_Cpvf_pvt = new Cpvf_pvt(1, 2)
-val Cpvf_pvt(extracted1i_Cpvf_pvt, extracted2i_Cpvf_pvt) = i_Cpvf_pvt
-val Cpvf_pvt(extracted1ch_Cpvf_pvt, extracted2ch_Cpvf_pvt) = ch_Cpvf_pvt
-assert(1 == extracted1i_Cpvf_pvt)
-assert(2 == extracted2i_Cpvf_pvt)
-assert('a' == extracted1ch_Cpvf_pvt)
-assert('b' == extracted2ch_Cpvf_pvt)
-
-assert(2 == i_Cpvf_pvt.p2)
-assert('b' == ch_Cpvf_pvt.p2)
-
-
-val ch_Cpvf_pvf = new Cpvf_pvf('a', 'b')
-val i_Cpvf_pvf = new Cpvf_pvf(1, 2)
-val Cpvf_pvf(extracted1i_Cpvf_pvf, extracted2i_Cpvf_pvf) = i_Cpvf_pvf
-val Cpvf_pvf(extracted1ch_Cpvf_pvf, extracted2ch_Cpvf_pvf) = ch_Cpvf_pvf
-assert(1 == extracted1i_Cpvf_pvf)
-assert(2 == extracted2i_Cpvf_pvf)
-assert('a' == extracted1ch_Cpvf_pvf)
-assert('b' == extracted2ch_Cpvf_pvf)
-
-
-
-val ch_Cpvf_vt = new Cpvf_vt('a', 'b')
-val i_Cpvf_vt = new Cpvf_vt(1, 2)
-val Cpvf_vt(extracted1i_Cpvf_vt, extracted2i_Cpvf_vt) = i_Cpvf_vt
-val Cpvf_vt(extracted1ch_Cpvf_vt, extracted2ch_Cpvf_vt) = ch_Cpvf_vt
-assert(1 == extracted1i_Cpvf_vt)
-assert(2 == extracted2i_Cpvf_vt)
-assert('a' == extracted1ch_Cpvf_vt)
-assert('b' == extracted2ch_Cpvf_vt)
-
-assert(2 == i_Cpvf_vt.a)
-assert('b' == ch_Cpvf_vt.a)
-assert(2 == i_Cpvf_vt.p2)
-assert('b' == ch_Cpvf_vt.p2)
-
-
-val ch_Cpvf_vf = new Cpvf_vf('a', 'b')
-val i_Cpvf_vf = new Cpvf_vf(1, 2)
-val Cpvf_vf(extracted1i_Cpvf_vf, extracted2i_Cpvf_vf) = i_Cpvf_vf
-val Cpvf_vf(extracted1ch_Cpvf_vf, extracted2ch_Cpvf_vf) = ch_Cpvf_vf
-assert(1 == extracted1i_Cpvf_vf)
-assert(2 == extracted2i_Cpvf_vf)
-assert('a' == extracted1ch_Cpvf_vf)
-assert('b' == extracted2ch_Cpvf_vf)
-
-assert(2 == i_Cpvf_vf.a)
-assert('b' == ch_Cpvf_vf.a)
-
-
-val ch_Cpvf_nt = new Cpvf_nt('a', 'b')
-val i_Cpvf_nt = new Cpvf_nt(1, 2)
-val Cpvf_nt(extracted1i_Cpvf_nt, extracted2i_Cpvf_nt) = i_Cpvf_nt
-val Cpvf_nt(extracted1ch_Cpvf_nt, extracted2ch_Cpvf_nt) = ch_Cpvf_nt
-assert(1 == extracted1i_Cpvf_nt)
-assert(2 == extracted2i_Cpvf_nt)
-assert('a' == extracted1ch_Cpvf_nt)
-assert('b' == extracted2ch_Cpvf_nt)
-
-assert(2 == i_Cpvf_nt.a)
-assert('b' == ch_Cpvf_nt.a)
-assert(2 == i_Cpvf_nt.p2)
-assert('b' == ch_Cpvf_nt.p2)
-
-
-val ch_Cpvf_nf = new Cpvf_nf('a', 'b')
-val i_Cpvf_nf = new Cpvf_nf(1, 2)
-val Cpvf_nf(extracted1i_Cpvf_nf, extracted2i_Cpvf_nf) = i_Cpvf_nf
-val Cpvf_nf(extracted1ch_Cpvf_nf, extracted2ch_Cpvf_nf) = ch_Cpvf_nf
-assert(1 == extracted1i_Cpvf_nf)
-assert(2 == extracted2i_Cpvf_nf)
-assert('a' == extracted1ch_Cpvf_nf)
-assert('b' == extracted2ch_Cpvf_nf)
-
-assert(2 == i_Cpvf_nf.a)
-assert('b' == ch_Cpvf_nf.a)
-
-
-val ch_Cvt_pvt = new Cvt_pvt('a', 'b')
-val i_Cvt_pvt = new Cvt_pvt(1, 2)
-val Cvt_pvt(extracted1i_Cvt_pvt, extracted2i_Cvt_pvt) = i_Cvt_pvt
-val Cvt_pvt(extracted1ch_Cvt_pvt, extracted2ch_Cvt_pvt) = ch_Cvt_pvt
-assert(1 == extracted1i_Cvt_pvt)
-assert(2 == extracted2i_Cvt_pvt)
-assert('a' == extracted1ch_Cvt_pvt)
-assert('b' == extracted2ch_Cvt_pvt)
-
-assert(1 == i_Cvt_pvt.`a b`)
-assert('a' == ch_Cvt_pvt.`a b`)
-assert(1 == i_Cvt_pvt.p1)
-assert(2 == i_Cvt_pvt.p2)
-assert('a' == ch_Cvt_pvt.p1)
-assert('b' == ch_Cvt_pvt.p2)
-
-
-val ch_Cvt_pvf = new Cvt_pvf('a', 'b')
-val i_Cvt_pvf = new Cvt_pvf(1, 2)
-val Cvt_pvf(extracted1i_Cvt_pvf, extracted2i_Cvt_pvf) = i_Cvt_pvf
-val Cvt_pvf(extracted1ch_Cvt_pvf, extracted2ch_Cvt_pvf) = ch_Cvt_pvf
-assert(1 == extracted1i_Cvt_pvf)
-assert(2 == extracted2i_Cvt_pvf)
-assert('a' == extracted1ch_Cvt_pvf)
-assert('b' == extracted2ch_Cvt_pvf)
-
-assert(1 == i_Cvt_pvf.`a b`)
-assert('a' == ch_Cvt_pvf.`a b`)
-assert(1 == i_Cvt_pvf.p1)
-assert('a' == ch_Cvt_pvf.p1)
-
-
-val ch_Cvt_vt = new Cvt_vt('a', 'b')
-val i_Cvt_vt = new Cvt_vt(1, 2)
-val Cvt_vt(extracted1i_Cvt_vt, extracted2i_Cvt_vt) = i_Cvt_vt
-val Cvt_vt(extracted1ch_Cvt_vt, extracted2ch_Cvt_vt) = ch_Cvt_vt
-assert(1 == extracted1i_Cvt_vt)
-assert(2 == extracted2i_Cvt_vt)
-assert('a' == extracted1ch_Cvt_vt)
-assert('b' == extracted2ch_Cvt_vt)
-
-assert(1 == i_Cvt_vt.`a b`)
-assert(2 == i_Cvt_vt.a)
-assert('a' == ch_Cvt_vt.`a b`)
-assert('b' == ch_Cvt_vt.a)
-assert(1 == i_Cvt_vt.p1)
-assert(2 == i_Cvt_vt.p2)
-assert('a' == ch_Cvt_vt.p1)
-assert('b' == ch_Cvt_vt.p2)
-
-
-val ch_Cvt_vf = new Cvt_vf('a', 'b')
-val i_Cvt_vf = new Cvt_vf(1, 2)
-val Cvt_vf(extracted1i_Cvt_vf, extracted2i_Cvt_vf) = i_Cvt_vf
-val Cvt_vf(extracted1ch_Cvt_vf, extracted2ch_Cvt_vf) = ch_Cvt_vf
-assert(1 == extracted1i_Cvt_vf)
-assert(2 == extracted2i_Cvt_vf)
-assert('a' == extracted1ch_Cvt_vf)
-assert('b' == extracted2ch_Cvt_vf)
-
-assert(1 == i_Cvt_vf.`a b`)
-assert(2 == i_Cvt_vf.a)
-assert('a' == ch_Cvt_vf.`a b`)
-assert('b' == ch_Cvt_vf.a)
-assert(1 == i_Cvt_vf.p1)
-assert('a' == ch_Cvt_vf.p1)
-
-
-val ch_Cvt_nt = new Cvt_nt('a', 'b')
-val i_Cvt_nt = new Cvt_nt(1, 2)
-val Cvt_nt(extracted1i_Cvt_nt, extracted2i_Cvt_nt) = i_Cvt_nt
-val Cvt_nt(extracted1ch_Cvt_nt, extracted2ch_Cvt_nt) = ch_Cvt_nt
-assert(1 == extracted1i_Cvt_nt)
-assert(2 == extracted2i_Cvt_nt)
-assert('a' == extracted1ch_Cvt_nt)
-assert('b' == extracted2ch_Cvt_nt)
-
-assert(1 == i_Cvt_nt.`a b`)
-assert(2 == i_Cvt_nt.a)
-assert('a' == ch_Cvt_nt.`a b`)
-assert('b' == ch_Cvt_nt.a)
-assert(1 == i_Cvt_nt.p1)
-assert(2 == i_Cvt_nt.p2)
-assert('a' == ch_Cvt_nt.p1)
-assert('b' == ch_Cvt_nt.p2)
-
-
-val ch_Cvt_nf = new Cvt_nf('a', 'b')
-val i_Cvt_nf = new Cvt_nf(1, 2)
-val Cvt_nf(extracted1i_Cvt_nf, extracted2i_Cvt_nf) = i_Cvt_nf
-val Cvt_nf(extracted1ch_Cvt_nf, extracted2ch_Cvt_nf) = ch_Cvt_nf
-assert(1 == extracted1i_Cvt_nf)
-assert(2 == extracted2i_Cvt_nf)
-assert('a' == extracted1ch_Cvt_nf)
-assert('b' == extracted2ch_Cvt_nf)
-
-assert(1 == i_Cvt_nf.`a b`)
-assert(2 == i_Cvt_nf.a)
-assert('a' == ch_Cvt_nf.`a b`)
-assert('b' == ch_Cvt_nf.a)
-assert(1 == i_Cvt_nf.p1)
-assert('a' == ch_Cvt_nf.p1)
-
-
-val ch_Cvf_pvt = new Cvf_pvt('a', 'b')
-val i_Cvf_pvt = new Cvf_pvt(1, 2)
-val Cvf_pvt(extracted1i_Cvf_pvt, extracted2i_Cvf_pvt) = i_Cvf_pvt
-val Cvf_pvt(extracted1ch_Cvf_pvt, extracted2ch_Cvf_pvt) = ch_Cvf_pvt
-assert(1 == extracted1i_Cvf_pvt)
-assert(2 == extracted2i_Cvf_pvt)
-assert('a' == extracted1ch_Cvf_pvt)
-assert('b' == extracted2ch_Cvf_pvt)
-
-assert(1 == i_Cvf_pvt.`a b`)
-assert('a' == ch_Cvf_pvt.`a b`)
-assert(2 == i_Cvf_pvt.p2)
-assert('b' == ch_Cvf_pvt.p2)
-
-
-val ch_Cvf_pvf = new Cvf_pvf('a', 'b')
-val i_Cvf_pvf = new Cvf_pvf(1, 2)
-val Cvf_pvf(extracted1i_Cvf_pvf, extracted2i_Cvf_pvf) = i_Cvf_pvf
-val Cvf_pvf(extracted1ch_Cvf_pvf, extracted2ch_Cvf_pvf) = ch_Cvf_pvf
-assert(1 == extracted1i_Cvf_pvf)
-assert(2 == extracted2i_Cvf_pvf)
-assert('a' == extracted1ch_Cvf_pvf)
-assert('b' == extracted2ch_Cvf_pvf)
-
-assert(1 == i_Cvf_pvf.`a b`)
-assert('a' == ch_Cvf_pvf.`a b`)
-
-
-val ch_Cvf_vt = new Cvf_vt('a', 'b')
-val i_Cvf_vt = new Cvf_vt(1, 2)
-val Cvf_vt(extracted1i_Cvf_vt, extracted2i_Cvf_vt) = i_Cvf_vt
-val Cvf_vt(extracted1ch_Cvf_vt, extracted2ch_Cvf_vt) = ch_Cvf_vt
-assert(1 == extracted1i_Cvf_vt)
-assert(2 == extracted2i_Cvf_vt)
-assert('a' == extracted1ch_Cvf_vt)
-assert('b' == extracted2ch_Cvf_vt)
-
-assert(1 == i_Cvf_vt.`a b`)
-assert(2 == i_Cvf_vt.a)
-assert('a' == ch_Cvf_vt.`a b`)
-assert('b' == ch_Cvf_vt.a)
-assert(2 == i_Cvf_vt.p2)
-assert('b' == ch_Cvf_vt.p2)
-
-
-val ch_Cvf_vf = new Cvf_vf('a', 'b')
-val i_Cvf_vf = new Cvf_vf(1, 2)
-val Cvf_vf(extracted1i_Cvf_vf, extracted2i_Cvf_vf) = i_Cvf_vf
-val Cvf_vf(extracted1ch_Cvf_vf, extracted2ch_Cvf_vf) = ch_Cvf_vf
-assert(1 == extracted1i_Cvf_vf)
-assert(2 == extracted2i_Cvf_vf)
-assert('a' == extracted1ch_Cvf_vf)
-assert('b' == extracted2ch_Cvf_vf)
-
-assert(1 == i_Cvf_vf.`a b`)
-assert(2 == i_Cvf_vf.a)
-assert('a' == ch_Cvf_vf.`a b`)
-assert('b' == ch_Cvf_vf.a)
-
-
-val ch_Cvf_nt = new Cvf_nt('a', 'b')
-val i_Cvf_nt = new Cvf_nt(1, 2)
-val Cvf_nt(extracted1i_Cvf_nt, extracted2i_Cvf_nt) = i_Cvf_nt
-val Cvf_nt(extracted1ch_Cvf_nt, extracted2ch_Cvf_nt) = ch_Cvf_nt
-assert(1 == extracted1i_Cvf_nt)
-assert(2 == extracted2i_Cvf_nt)
-assert('a' == extracted1ch_Cvf_nt)
-assert('b' == extracted2ch_Cvf_nt)
-
-assert(1 == i_Cvf_nt.`a b`)
-assert(2 == i_Cvf_nt.a)
-assert('a' == ch_Cvf_nt.`a b`)
-assert('b' == ch_Cvf_nt.a)
-assert(2 == i_Cvf_nt.p2)
-assert('b' == ch_Cvf_nt.p2)
-
-
-val ch_Cvf_nf = new Cvf_nf('a', 'b')
-val i_Cvf_nf = new Cvf_nf(1, 2)
-val Cvf_nf(extracted1i_Cvf_nf, extracted2i_Cvf_nf) = i_Cvf_nf
-val Cvf_nf(extracted1ch_Cvf_nf, extracted2ch_Cvf_nf) = ch_Cvf_nf
-assert(1 == extracted1i_Cvf_nf)
-assert(2 == extracted2i_Cvf_nf)
-assert('a' == extracted1ch_Cvf_nf)
-assert('b' == extracted2ch_Cvf_nf)
-
-assert(1 == i_Cvf_nf.`a b`)
-assert(2 == i_Cvf_nf.a)
-assert('a' == ch_Cvf_nf.`a b`)
-assert('b' == ch_Cvf_nf.a)
-
-
-val ch_Cnt_pvt = new Cnt_pvt('a', 'b')
-val i_Cnt_pvt = new Cnt_pvt(1, 2)
-val Cnt_pvt(extracted1i_Cnt_pvt, extracted2i_Cnt_pvt) = i_Cnt_pvt
-val Cnt_pvt(extracted1ch_Cnt_pvt, extracted2ch_Cnt_pvt) = ch_Cnt_pvt
-assert(1 == extracted1i_Cnt_pvt)
-assert(2 == extracted2i_Cnt_pvt)
-assert('a' == extracted1ch_Cnt_pvt)
-assert('b' == extracted2ch_Cnt_pvt)
-
-assert(1 == i_Cnt_pvt.`a b`)
-assert('a' == ch_Cnt_pvt.`a b`)
-assert(1 == i_Cnt_pvt.p1)
-assert(2 == i_Cnt_pvt.p2)
-assert('a' == ch_Cnt_pvt.p1)
-assert('b' == ch_Cnt_pvt.p2)
-
-
-val ch_Cnt_pvf = new Cnt_pvf('a', 'b')
-val i_Cnt_pvf = new Cnt_pvf(1, 2)
-val Cnt_pvf(extracted1i_Cnt_pvf, extracted2i_Cnt_pvf) = i_Cnt_pvf
-val Cnt_pvf(extracted1ch_Cnt_pvf, extracted2ch_Cnt_pvf) = ch_Cnt_pvf
-assert(1 == extracted1i_Cnt_pvf)
-assert(2 == extracted2i_Cnt_pvf)
-assert('a' == extracted1ch_Cnt_pvf)
-assert('b' == extracted2ch_Cnt_pvf)
-
-assert(1 == i_Cnt_pvf.`a b`)
-assert('a' == ch_Cnt_pvf.`a b`)
-assert(1 == i_Cnt_pvf.p1)
-assert('a' == ch_Cnt_pvf.p1)
-
-
-val ch_Cnt_vt = new Cnt_vt('a', 'b')
-val i_Cnt_vt = new Cnt_vt(1, 2)
-val Cnt_vt(extracted1i_Cnt_vt, extracted2i_Cnt_vt) = i_Cnt_vt
-val Cnt_vt(extracted1ch_Cnt_vt, extracted2ch_Cnt_vt) = ch_Cnt_vt
-assert(1 == extracted1i_Cnt_vt)
-assert(2 == extracted2i_Cnt_vt)
-assert('a' == extracted1ch_Cnt_vt)
-assert('b' == extracted2ch_Cnt_vt)
-
-assert(1 == i_Cnt_vt.`a b`)
-assert(2 == i_Cnt_vt.a)
-assert('a' == ch_Cnt_vt.`a b`)
-assert('b' == ch_Cnt_vt.a)
-assert(1 == i_Cnt_vt.p1)
-assert(2 == i_Cnt_vt.p2)
-assert('a' == ch_Cnt_vt.p1)
-assert('b' == ch_Cnt_vt.p2)
-
-
-val ch_Cnt_vf = new Cnt_vf('a', 'b')
-val i_Cnt_vf = new Cnt_vf(1, 2)
-val Cnt_vf(extracted1i_Cnt_vf, extracted2i_Cnt_vf) = i_Cnt_vf
-val Cnt_vf(extracted1ch_Cnt_vf, extracted2ch_Cnt_vf) = ch_Cnt_vf
-assert(1 == extracted1i_Cnt_vf)
-assert(2 == extracted2i_Cnt_vf)
-assert('a' == extracted1ch_Cnt_vf)
-assert('b' == extracted2ch_Cnt_vf)
-
-assert(1 == i_Cnt_vf.`a b`)
-assert(2 == i_Cnt_vf.a)
-assert('a' == ch_Cnt_vf.`a b`)
-assert('b' == ch_Cnt_vf.a)
-assert(1 == i_Cnt_vf.p1)
-assert('a' == ch_Cnt_vf.p1)
-
-
-val ch_Cnt_nt = new Cnt_nt('a', 'b')
-val i_Cnt_nt = new Cnt_nt(1, 2)
-val Cnt_nt(extracted1i_Cnt_nt, extracted2i_Cnt_nt) = i_Cnt_nt
-val Cnt_nt(extracted1ch_Cnt_nt, extracted2ch_Cnt_nt) = ch_Cnt_nt
-assert(1 == extracted1i_Cnt_nt)
-assert(2 == extracted2i_Cnt_nt)
-assert('a' == extracted1ch_Cnt_nt)
-assert('b' == extracted2ch_Cnt_nt)
-
-assert(1 == i_Cnt_nt.`a b`)
-assert(2 == i_Cnt_nt.a)
-assert('a' == ch_Cnt_nt.`a b`)
-assert('b' == ch_Cnt_nt.a)
-assert(1 == i_Cnt_nt.p1)
-assert(2 == i_Cnt_nt.p2)
-assert('a' == ch_Cnt_nt.p1)
-assert('b' == ch_Cnt_nt.p2)
-
-
-val ch_Cnt_nf = new Cnt_nf('a', 'b')
-val i_Cnt_nf = new Cnt_nf(1, 2)
-val Cnt_nf(extracted1i_Cnt_nf, extracted2i_Cnt_nf) = i_Cnt_nf
-val Cnt_nf(extracted1ch_Cnt_nf, extracted2ch_Cnt_nf) = ch_Cnt_nf
-assert(1 == extracted1i_Cnt_nf)
-assert(2 == extracted2i_Cnt_nf)
-assert('a' == extracted1ch_Cnt_nf)
-assert('b' == extracted2ch_Cnt_nf)
-
-assert(1 == i_Cnt_nf.`a b`)
-assert(2 == i_Cnt_nf.a)
-assert('a' == ch_Cnt_nf.`a b`)
-assert('b' == ch_Cnt_nf.a)
-assert(1 == i_Cnt_nf.p1)
-assert('a' == ch_Cnt_nf.p1)
-
-
-val ch_Cnf_pvt = new Cnf_pvt('a', 'b')
-val i_Cnf_pvt = new Cnf_pvt(1, 2)
-val Cnf_pvt(extracted1i_Cnf_pvt, extracted2i_Cnf_pvt) = i_Cnf_pvt
-val Cnf_pvt(extracted1ch_Cnf_pvt, extracted2ch_Cnf_pvt) = ch_Cnf_pvt
-assert(1 == extracted1i_Cnf_pvt)
-assert(2 == extracted2i_Cnf_pvt)
-assert('a' == extracted1ch_Cnf_pvt)
-assert('b' == extracted2ch_Cnf_pvt)
-
-assert(1 == i_Cnf_pvt.`a b`)
-assert('a' == ch_Cnf_pvt.`a b`)
-assert(2 == i_Cnf_pvt.p2)
-assert('b' == ch_Cnf_pvt.p2)
-
-
-val ch_Cnf_pvf = new Cnf_pvf('a', 'b')
-val i_Cnf_pvf = new Cnf_pvf(1, 2)
-val Cnf_pvf(extracted1i_Cnf_pvf, extracted2i_Cnf_pvf) = i_Cnf_pvf
-val Cnf_pvf(extracted1ch_Cnf_pvf, extracted2ch_Cnf_pvf) = ch_Cnf_pvf
-assert(1 == extracted1i_Cnf_pvf)
-assert(2 == extracted2i_Cnf_pvf)
-assert('a' == extracted1ch_Cnf_pvf)
-assert('b' == extracted2ch_Cnf_pvf)
-
-assert(1 == i_Cnf_pvf.`a b`)
-assert('a' == ch_Cnf_pvf.`a b`)
-
-
-val ch_Cnf_vt = new Cnf_vt('a', 'b')
-val i_Cnf_vt = new Cnf_vt(1, 2)
-val Cnf_vt(extracted1i_Cnf_vt, extracted2i_Cnf_vt) = i_Cnf_vt
-val Cnf_vt(extracted1ch_Cnf_vt, extracted2ch_Cnf_vt) = ch_Cnf_vt
-assert(1 == extracted1i_Cnf_vt)
-assert(2 == extracted2i_Cnf_vt)
-assert('a' == extracted1ch_Cnf_vt)
-assert('b' == extracted2ch_Cnf_vt)
-
-assert(1 == i_Cnf_vt.`a b`)
-assert(2 == i_Cnf_vt.a)
-assert('a' == ch_Cnf_vt.`a b`)
-assert('b' == ch_Cnf_vt.a)
-assert(2 == i_Cnf_vt.p2)
-assert('b' == ch_Cnf_vt.p2)
-
-
-val ch_Cnf_vf = new Cnf_vf('a', 'b')
-val i_Cnf_vf = new Cnf_vf(1, 2)
-val Cnf_vf(extracted1i_Cnf_vf, extracted2i_Cnf_vf) = i_Cnf_vf
-val Cnf_vf(extracted1ch_Cnf_vf, extracted2ch_Cnf_vf) = ch_Cnf_vf
-assert(1 == extracted1i_Cnf_vf)
-assert(2 == extracted2i_Cnf_vf)
-assert('a' == extracted1ch_Cnf_vf)
-assert('b' == extracted2ch_Cnf_vf)
-
-assert(1 == i_Cnf_vf.`a b`)
-assert(2 == i_Cnf_vf.a)
-assert('a' == ch_Cnf_vf.`a b`)
-assert('b' == ch_Cnf_vf.a)
-
-
-val ch_Cnf_nt = new Cnf_nt('a', 'b')
-val i_Cnf_nt = new Cnf_nt(1, 2)
-val Cnf_nt(extracted1i_Cnf_nt, extracted2i_Cnf_nt) = i_Cnf_nt
-val Cnf_nt(extracted1ch_Cnf_nt, extracted2ch_Cnf_nt) = ch_Cnf_nt
-assert(1 == extracted1i_Cnf_nt)
-assert(2 == extracted2i_Cnf_nt)
-assert('a' == extracted1ch_Cnf_nt)
-assert('b' == extracted2ch_Cnf_nt)
-
-assert(1 == i_Cnf_nt.`a b`)
-assert(2 == i_Cnf_nt.a)
-assert('a' == ch_Cnf_nt.`a b`)
-assert('b' == ch_Cnf_nt.a)
-assert(2 == i_Cnf_nt.p2)
-assert('b' == ch_Cnf_nt.p2)
-
-
-val ch_Cnf_nf = new Cnf_nf('a', 'b')
-val i_Cnf_nf = new Cnf_nf(1, 2)
-val Cnf_nf(extracted1i_Cnf_nf, extracted2i_Cnf_nf) = i_Cnf_nf
-val Cnf_nf(extracted1ch_Cnf_nf, extracted2ch_Cnf_nf) = ch_Cnf_nf
-assert(1 == extracted1i_Cnf_nf)
-assert(2 == extracted2i_Cnf_nf)
-assert('a' == extracted1ch_Cnf_nf)
-assert('b' == extracted2ch_Cnf_nf)
-
-assert(1 == i_Cnf_nf.`a b`)
-assert(2 == i_Cnf_nf.a)
-assert('a' == ch_Cnf_nf.`a b`)
-assert('b' == ch_Cnf_nf.a)
-
-
-val ch_Rpvt_pvt = new Rpvt_pvt('a', 'b')
-val i_Rpvt_pvt = new Rpvt_pvt(1, 2)
-assert(1 == i_Rpvt_pvt.p1)
-assert(2 == i_Rpvt_pvt.p2)
-assert('a' == ch_Rpvt_pvt.p1)
-assert('b' == ch_Rpvt_pvt.p2)
-
-
-val ch_Rpvt_pvf = new Rpvt_pvf('a', 'b')
-val i_Rpvt_pvf = new Rpvt_pvf(1, 2)
-assert(1 == i_Rpvt_pvf.p1)
-assert('a' == ch_Rpvt_pvf.p1)
-
-
-val ch_Rpvt_vt = new Rpvt_vt('a', 'b')
-val i_Rpvt_vt = new Rpvt_vt(1, 2)
-assert(2 == i_Rpvt_vt.a)
-assert('b' == ch_Rpvt_vt.a)
-assert(1 == i_Rpvt_vt.p1)
-assert(2 == i_Rpvt_vt.p2)
-assert('a' == ch_Rpvt_vt.p1)
-assert('b' == ch_Rpvt_vt.p2)
-
-
-val ch_Rpvt_vf = new Rpvt_vf('a', 'b')
-val i_Rpvt_vf = new Rpvt_vf(1, 2)
-assert(2 == i_Rpvt_vf.a)
-assert('b' == ch_Rpvt_vf.a)
-assert(1 == i_Rpvt_vf.p1)
-assert('a' == ch_Rpvt_vf.p1)
-
-
-val ch_Rpvt_nt = new Rpvt_nt('a', 'b')
-val i_Rpvt_nt = new Rpvt_nt(1, 2)
-assert(1 == i_Rpvt_nt.p1)
-assert(2 == i_Rpvt_nt.p2)
-assert('a' == ch_Rpvt_nt.p1)
-assert('b' == ch_Rpvt_nt.p2)
-
-
-val ch_Rpvt_nf = new Rpvt_nf('a', 'b')
-val i_Rpvt_nf = new Rpvt_nf(1, 2)
-assert(1 == i_Rpvt_nf.p1)
-assert('a' == ch_Rpvt_nf.p1)
-
-
-val ch_Rpvf_pvt = new Rpvf_pvt('a', 'b')
-val i_Rpvf_pvt = new Rpvf_pvt(1, 2)
-assert(2 == i_Rpvf_pvt.p2)
-assert('b' == ch_Rpvf_pvt.p2)
-
-
-val ch_Rpvf_pvf = new Rpvf_pvf('a', 'b')
-val i_Rpvf_pvf = new Rpvf_pvf(1, 2)
-
-
-val ch_Rpvf_vt = new Rpvf_vt('a', 'b')
-val i_Rpvf_vt = new Rpvf_vt(1, 2)
-assert(2 == i_Rpvf_vt.a)
-assert('b' == ch_Rpvf_vt.a)
-assert(2 == i_Rpvf_vt.p2)
-assert('b' == ch_Rpvf_vt.p2)
-
-
-val ch_Rpvf_vf = new Rpvf_vf('a', 'b')
-val i_Rpvf_vf = new Rpvf_vf(1, 2)
-assert(2 == i_Rpvf_vf.a)
-assert('b' == ch_Rpvf_vf.a)
-
-
-val ch_Rpvf_nt = new Rpvf_nt('a', 'b')
-val i_Rpvf_nt = new Rpvf_nt(1, 2)
-assert(2 == i_Rpvf_nt.p2)
-assert('b' == ch_Rpvf_nt.p2)
-
-
-val ch_Rpvf_nf = new Rpvf_nf('a', 'b')
-val i_Rpvf_nf = new Rpvf_nf(1, 2)
-
-
-val ch_Rvt_pvt = new Rvt_pvt('a', 'b')
-val i_Rvt_pvt = new Rvt_pvt(1, 2)
-assert(1 == i_Rvt_pvt.`a b`)
-assert('a' == ch_Rvt_pvt.`a b`)
-assert(1 == i_Rvt_pvt.p1)
-assert(2 == i_Rvt_pvt.p2)
-assert('a' == ch_Rvt_pvt.p1)
-assert('b' == ch_Rvt_pvt.p2)
-
-
-val ch_Rvt_pvf = new Rvt_pvf('a', 'b')
-val i_Rvt_pvf = new Rvt_pvf(1, 2)
-assert(1 == i_Rvt_pvf.`a b`)
-assert('a' == ch_Rvt_pvf.`a b`)
-assert(1 == i_Rvt_pvf.p1)
-assert('a' == ch_Rvt_pvf.p1)
-
-
-val ch_Rvt_vt = new Rvt_vt('a', 'b')
-val i_Rvt_vt = new Rvt_vt(1, 2)
-assert(1 == i_Rvt_vt.`a b`)
-assert(2 == i_Rvt_vt.a)
-assert('a' == ch_Rvt_vt.`a b`)
-assert('b' == ch_Rvt_vt.a)
-assert(1 == i_Rvt_vt.p1)
-assert(2 == i_Rvt_vt.p2)
-assert('a' == ch_Rvt_vt.p1)
-assert('b' == ch_Rvt_vt.p2)
-
-
-val ch_Rvt_vf = new Rvt_vf('a', 'b')
-val i_Rvt_vf = new Rvt_vf(1, 2)
-assert(1 == i_Rvt_vf.`a b`)
-assert(2 == i_Rvt_vf.a)
-assert('a' == ch_Rvt_vf.`a b`)
-assert('b' == ch_Rvt_vf.a)
-assert(1 == i_Rvt_vf.p1)
-assert('a' == ch_Rvt_vf.p1)
-
-
-val ch_Rvt_nt = new Rvt_nt('a', 'b')
-val i_Rvt_nt = new Rvt_nt(1, 2)
-assert(1 == i_Rvt_nt.`a b`)
-assert('a' == ch_Rvt_nt.`a b`)
-assert(1 == i_Rvt_nt.p1)
-assert(2 == i_Rvt_nt.p2)
-assert('a' == ch_Rvt_nt.p1)
-assert('b' == ch_Rvt_nt.p2)
-
-
-val ch_Rvt_nf = new Rvt_nf('a', 'b')
-val i_Rvt_nf = new Rvt_nf(1, 2)
-assert(1 == i_Rvt_nf.`a b`)
-assert('a' == ch_Rvt_nf.`a b`)
-assert(1 == i_Rvt_nf.p1)
-assert('a' == ch_Rvt_nf.p1)
-
-
-val ch_Rvf_pvt = new Rvf_pvt('a', 'b')
-val i_Rvf_pvt = new Rvf_pvt(1, 2)
-assert(1 == i_Rvf_pvt.`a b`)
-assert('a' == ch_Rvf_pvt.`a b`)
-assert(2 == i_Rvf_pvt.p2)
-assert('b' == ch_Rvf_pvt.p2)
-
-
-val ch_Rvf_pvf = new Rvf_pvf('a', 'b')
-val i_Rvf_pvf = new Rvf_pvf(1, 2)
-assert(1 == i_Rvf_pvf.`a b`)
-assert('a' == ch_Rvf_pvf.`a b`)
-
-
-val ch_Rvf_vt = new Rvf_vt('a', 'b')
-val i_Rvf_vt = new Rvf_vt(1, 2)
-assert(1 == i_Rvf_vt.`a b`)
-assert(2 == i_Rvf_vt.a)
-assert('a' == ch_Rvf_vt.`a b`)
-assert('b' == ch_Rvf_vt.a)
-assert(2 == i_Rvf_vt.p2)
-assert('b' == ch_Rvf_vt.p2)
-
-
-val ch_Rvf_vf = new Rvf_vf('a', 'b')
-val i_Rvf_vf = new Rvf_vf(1, 2)
-assert(1 == i_Rvf_vf.`a b`)
-assert(2 == i_Rvf_vf.a)
-assert('a' == ch_Rvf_vf.`a b`)
-assert('b' == ch_Rvf_vf.a)
-
-
-val ch_Rvf_nt = new Rvf_nt('a', 'b')
-val i_Rvf_nt = new Rvf_nt(1, 2)
-assert(1 == i_Rvf_nt.`a b`)
-assert('a' == ch_Rvf_nt.`a b`)
-assert(2 == i_Rvf_nt.p2)
-assert('b' == ch_Rvf_nt.p2)
-
-
-val ch_Rvf_nf = new Rvf_nf('a', 'b')
-val i_Rvf_nf = new Rvf_nf(1, 2)
-assert(1 == i_Rvf_nf.`a b`)
-assert('a' == ch_Rvf_nf.`a b`)
-
-
-val ch_Rnt_pvt = new Rnt_pvt('a', 'b')
-val i_Rnt_pvt = new Rnt_pvt(1, 2)
-assert(1 == i_Rnt_pvt.p1)
-assert(2 == i_Rnt_pvt.p2)
-assert('a' == ch_Rnt_pvt.p1)
-assert('b' == ch_Rnt_pvt.p2)
-
-
-val ch_Rnt_pvf = new Rnt_pvf('a', 'b')
-val i_Rnt_pvf = new Rnt_pvf(1, 2)
-assert(1 == i_Rnt_pvf.p1)
-assert('a' == ch_Rnt_pvf.p1)
-
-
-val ch_Rnt_vt = new Rnt_vt('a', 'b')
-val i_Rnt_vt = new Rnt_vt(1, 2)
-assert(2 == i_Rnt_vt.a)
-assert('b' == ch_Rnt_vt.a)
-assert(1 == i_Rnt_vt.p1)
-assert(2 == i_Rnt_vt.p2)
-assert('a' == ch_Rnt_vt.p1)
-assert('b' == ch_Rnt_vt.p2)
-
-
-val ch_Rnt_vf = new Rnt_vf('a', 'b')
-val i_Rnt_vf = new Rnt_vf(1, 2)
-assert(2 == i_Rnt_vf.a)
-assert('b' == ch_Rnt_vf.a)
-assert(1 == i_Rnt_vf.p1)
-assert('a' == ch_Rnt_vf.p1)
-
-
-val ch_Rnt_nt = new Rnt_nt('a', 'b')
-val i_Rnt_nt = new Rnt_nt(1, 2)
-assert(1 == i_Rnt_nt.p1)
-assert(2 == i_Rnt_nt.p2)
-assert('a' == ch_Rnt_nt.p1)
-assert('b' == ch_Rnt_nt.p2)
-
-
-val ch_Rnt_nf = new Rnt_nf('a', 'b')
-val i_Rnt_nf = new Rnt_nf(1, 2)
-assert(1 == i_Rnt_nf.p1)
-assert('a' == ch_Rnt_nf.p1)
-
-
-val ch_Rnf_pvt = new Rnf_pvt('a', 'b')
-val i_Rnf_pvt = new Rnf_pvt(1, 2)
-assert(2 == i_Rnf_pvt.p2)
-assert('b' == ch_Rnf_pvt.p2)
-
-
-val ch_Rnf_pvf = new Rnf_pvf('a', 'b')
-val i_Rnf_pvf = new Rnf_pvf(1, 2)
-
-
-val ch_Rnf_vt = new Rnf_vt('a', 'b')
-val i_Rnf_vt = new Rnf_vt(1, 2)
-assert(2 == i_Rnf_vt.a)
-assert('b' == ch_Rnf_vt.a)
-assert(2 == i_Rnf_vt.p2)
-assert('b' == ch_Rnf_vt.p2)
-
-
-val ch_Rnf_vf = new Rnf_vf('a', 'b')
-val i_Rnf_vf = new Rnf_vf(1, 2)
-assert(2 == i_Rnf_vf.a)
-assert('b' == ch_Rnf_vf.a)
-
-
-val ch_Rnf_nt = new Rnf_nt('a', 'b')
-val i_Rnf_nt = new Rnf_nt(1, 2)
-assert(2 == i_Rnf_nt.p2)
-assert('b' == ch_Rnf_nt.p2)
-
-
-val ch_Rnf_nf = new Rnf_nf('a', 'b')
-val i_Rnf_nf = new Rnf_nf(1, 2)
+val ch_Cpv_pv = new Cpv_pv('a', 'b')
+val i_Cpv_pv = new Cpv_pv(1, 2)
+val Cpv_pv(extracted1i_Cpv_pv, extracted2i_Cpv_pv) = i_Cpv_pv
+val Cpv_pv(extracted1ch_Cpv_pv, extracted2ch_Cpv_pv) = ch_Cpv_pv
+assert(1 == extracted1i_Cpv_pv)
+assert(2 == extracted2i_Cpv_pv)
+assert('a' == extracted1ch_Cpv_pv)
+assert('b' == extracted2ch_Cpv_pv)
+
+assert(1 == i_Cpv_pv.p1)
+assert(2 == i_Cpv_pv.p2)
+assert('a' == ch_Cpv_pv.p1)
+assert('b' == ch_Cpv_pv.p2)
+
+
+val ch_Cpv_v = new Cpv_v('a', 'b')
+val i_Cpv_v = new Cpv_v(1, 2)
+val Cpv_v(extracted1i_Cpv_v, extracted2i_Cpv_v) = i_Cpv_v
+val Cpv_v(extracted1ch_Cpv_v, extracted2ch_Cpv_v) = ch_Cpv_v
+assert(1 == extracted1i_Cpv_v)
+assert(2 == extracted2i_Cpv_v)
+assert('a' == extracted1ch_Cpv_v)
+assert('b' == extracted2ch_Cpv_v)
+
+assert(2 == i_Cpv_v.a)
+assert('b' == ch_Cpv_v.a)
+assert(1 == i_Cpv_v.p1)
+assert(2 == i_Cpv_v.p2)
+assert('a' == ch_Cpv_v.p1)
+assert('b' == ch_Cpv_v.p2)
+
+
+val ch_Cpv_n = new Cpv_n('a', 'b')
+val i_Cpv_n = new Cpv_n(1, 2)
+val Cpv_n(extracted1i_Cpv_n, extracted2i_Cpv_n) = i_Cpv_n
+val Cpv_n(extracted1ch_Cpv_n, extracted2ch_Cpv_n) = ch_Cpv_n
+assert(1 == extracted1i_Cpv_n)
+assert(2 == extracted2i_Cpv_n)
+assert('a' == extracted1ch_Cpv_n)
+assert('b' == extracted2ch_Cpv_n)
+
+assert(2 == i_Cpv_n.a)
+assert('b' == ch_Cpv_n.a)
+assert(1 == i_Cpv_n.p1)
+assert(2 == i_Cpv_n.p2)
+assert('a' == ch_Cpv_n.p1)
+assert('b' == ch_Cpv_n.p2)
+
+
+val ch_Cv_pv = new Cv_pv('a', 'b')
+val i_Cv_pv = new Cv_pv(1, 2)
+val Cv_pv(extracted1i_Cv_pv, extracted2i_Cv_pv) = i_Cv_pv
+val Cv_pv(extracted1ch_Cv_pv, extracted2ch_Cv_pv) = ch_Cv_pv
+assert(1 == extracted1i_Cv_pv)
+assert(2 == extracted2i_Cv_pv)
+assert('a' == extracted1ch_Cv_pv)
+assert('b' == extracted2ch_Cv_pv)
+
+assert(1 == i_Cv_pv.`a b`)
+assert('a' == ch_Cv_pv.`a b`)
+assert(1 == i_Cv_pv.p1)
+assert(2 == i_Cv_pv.p2)
+assert('a' == ch_Cv_pv.p1)
+assert('b' == ch_Cv_pv.p2)
+
+
+val ch_Cv_v = new Cv_v('a', 'b')
+val i_Cv_v = new Cv_v(1, 2)
+val Cv_v(extracted1i_Cv_v, extracted2i_Cv_v) = i_Cv_v
+val Cv_v(extracted1ch_Cv_v, extracted2ch_Cv_v) = ch_Cv_v
+assert(1 == extracted1i_Cv_v)
+assert(2 == extracted2i_Cv_v)
+assert('a' == extracted1ch_Cv_v)
+assert('b' == extracted2ch_Cv_v)
+
+assert(1 == i_Cv_v.`a b`)
+assert(2 == i_Cv_v.a)
+assert('a' == ch_Cv_v.`a b`)
+assert('b' == ch_Cv_v.a)
+assert(1 == i_Cv_v.p1)
+assert(2 == i_Cv_v.p2)
+assert('a' == ch_Cv_v.p1)
+assert('b' == ch_Cv_v.p2)
+
+
+val ch_Cv_n = new Cv_n('a', 'b')
+val i_Cv_n = new Cv_n(1, 2)
+val Cv_n(extracted1i_Cv_n, extracted2i_Cv_n) = i_Cv_n
+val Cv_n(extracted1ch_Cv_n, extracted2ch_Cv_n) = ch_Cv_n
+assert(1 == extracted1i_Cv_n)
+assert(2 == extracted2i_Cv_n)
+assert('a' == extracted1ch_Cv_n)
+assert('b' == extracted2ch_Cv_n)
+
+assert(1 == i_Cv_n.`a b`)
+assert(2 == i_Cv_n.a)
+assert('a' == ch_Cv_n.`a b`)
+assert('b' == ch_Cv_n.a)
+assert(1 == i_Cv_n.p1)
+assert(2 == i_Cv_n.p2)
+assert('a' == ch_Cv_n.p1)
+assert('b' == ch_Cv_n.p2)
+
+
+val ch_Cn_pv = new Cn_pv('a', 'b')
+val i_Cn_pv = new Cn_pv(1, 2)
+val Cn_pv(extracted1i_Cn_pv, extracted2i_Cn_pv) = i_Cn_pv
+val Cn_pv(extracted1ch_Cn_pv, extracted2ch_Cn_pv) = ch_Cn_pv
+assert(1 == extracted1i_Cn_pv)
+assert(2 == extracted2i_Cn_pv)
+assert('a' == extracted1ch_Cn_pv)
+assert('b' == extracted2ch_Cn_pv)
+
+assert(1 == i_Cn_pv.`a b`)
+assert('a' == ch_Cn_pv.`a b`)
+assert(1 == i_Cn_pv.p1)
+assert(2 == i_Cn_pv.p2)
+assert('a' == ch_Cn_pv.p1)
+assert('b' == ch_Cn_pv.p2)
+
+
+val ch_Cn_v = new Cn_v('a', 'b')
+val i_Cn_v = new Cn_v(1, 2)
+val Cn_v(extracted1i_Cn_v, extracted2i_Cn_v) = i_Cn_v
+val Cn_v(extracted1ch_Cn_v, extracted2ch_Cn_v) = ch_Cn_v
+assert(1 == extracted1i_Cn_v)
+assert(2 == extracted2i_Cn_v)
+assert('a' == extracted1ch_Cn_v)
+assert('b' == extracted2ch_Cn_v)
+
+assert(1 == i_Cn_v.`a b`)
+assert(2 == i_Cn_v.a)
+assert('a' == ch_Cn_v.`a b`)
+assert('b' == ch_Cn_v.a)
+assert(1 == i_Cn_v.p1)
+assert(2 == i_Cn_v.p2)
+assert('a' == ch_Cn_v.p1)
+assert('b' == ch_Cn_v.p2)
+
+
+val ch_Cn_n = new Cn_n('a', 'b')
+val i_Cn_n = new Cn_n(1, 2)
+val Cn_n(extracted1i_Cn_n, extracted2i_Cn_n) = i_Cn_n
+val Cn_n(extracted1ch_Cn_n, extracted2ch_Cn_n) = ch_Cn_n
+assert(1 == extracted1i_Cn_n)
+assert(2 == extracted2i_Cn_n)
+assert('a' == extracted1ch_Cn_n)
+assert('b' == extracted2ch_Cn_n)
+
+assert(1 == i_Cn_n.`a b`)
+assert(2 == i_Cn_n.a)
+assert('a' == ch_Cn_n.`a b`)
+assert('b' == ch_Cn_n.a)
+assert(1 == i_Cn_n.p1)
+assert(2 == i_Cn_n.p2)
+assert('a' == ch_Cn_n.p1)
+assert('b' == ch_Cn_n.p2)
+
+
+val ch_Rpv_pv = new Rpv_pv('a', 'b')
+val i_Rpv_pv = new Rpv_pv(1, 2)
+assert(1 == i_Rpv_pv.p1)
+assert(2 == i_Rpv_pv.p2)
+assert('a' == ch_Rpv_pv.p1)
+assert('b' == ch_Rpv_pv.p2)
+
+
+val ch_Rpv_v = new Rpv_v('a', 'b')
+val i_Rpv_v = new Rpv_v(1, 2)
+assert(2 == i_Rpv_v.a)
+assert('b' == ch_Rpv_v.a)
+assert(1 == i_Rpv_v.p1)
+assert(2 == i_Rpv_v.p2)
+assert('a' == ch_Rpv_v.p1)
+assert('b' == ch_Rpv_v.p2)
+
+
+val ch_Rpv_n = new Rpv_n('a', 'b')
+val i_Rpv_n = new Rpv_n(1, 2)
+assert(1 == i_Rpv_n.p1)
+assert(2 == i_Rpv_n.p2)
+assert('a' == ch_Rpv_n.p1)
+assert('b' == ch_Rpv_n.p2)
+
+
+val ch_Rv_pv = new Rv_pv('a', 'b')
+val i_Rv_pv = new Rv_pv(1, 2)
+assert(1 == i_Rv_pv.`a b`)
+assert('a' == ch_Rv_pv.`a b`)
+assert(1 == i_Rv_pv.p1)
+assert(2 == i_Rv_pv.p2)
+assert('a' == ch_Rv_pv.p1)
+assert('b' == ch_Rv_pv.p2)
+
+
+val ch_Rv_v = new Rv_v('a', 'b')
+val i_Rv_v = new Rv_v(1, 2)
+assert(1 == i_Rv_v.`a b`)
+assert(2 == i_Rv_v.a)
+assert('a' == ch_Rv_v.`a b`)
+assert('b' == ch_Rv_v.a)
+assert(1 == i_Rv_v.p1)
+assert(2 == i_Rv_v.p2)
+assert('a' == ch_Rv_v.p1)
+assert('b' == ch_Rv_v.p2)
+
+
+val ch_Rv_n = new Rv_n('a', 'b')
+val i_Rv_n = new Rv_n(1, 2)
+assert(1 == i_Rv_n.`a b`)
+assert('a' == ch_Rv_n.`a b`)
+assert(1 == i_Rv_n.p1)
+assert(2 == i_Rv_n.p2)
+assert('a' == ch_Rv_n.p1)
+assert('b' == ch_Rv_n.p2)
+
+
+val ch_Rn_pv = new Rn_pv('a', 'b')
+val i_Rn_pv = new Rn_pv(1, 2)
+assert(1 == i_Rn_pv.p1)
+assert(2 == i_Rn_pv.p2)
+assert('a' == ch_Rn_pv.p1)
+assert('b' == ch_Rn_pv.p2)
+
+
+val ch_Rn_v = new Rn_v('a', 'b')
+val i_Rn_v = new Rn_v(1, 2)
+assert(2 == i_Rn_v.a)
+assert('b' == ch_Rn_v.a)
+assert(1 == i_Rn_v.p1)
+assert(2 == i_Rn_v.p2)
+assert('a' == ch_Rn_v.p1)
+assert('b' == ch_Rn_v.p2)
+
+
+val ch_Rn_n = new Rn_n('a', 'b')
+val i_Rn_n = new Rn_n(1, 2)
+assert(1 == i_Rn_n.p1)
+assert(2 == i_Rn_n.p2)
+assert('a' == ch_Rn_n.p1)
+assert('b' == ch_Rn_n.p2)
 
 TestJoint.joint()
 }
diff --git a/test/files/run/t8831_many/generator.scala b/test/files/run/t8831_many/generator.scala
index 287dcde8f24c..658647d702d5 100644
--- a/test/files/run/t8831_many/generator.scala
+++ b/test/files/run/t8831_many/generator.scala
@@ -2,18 +2,18 @@
 case class TestCase(classType: String, p1: ParamConfig, p2: ParamConfig) {
   val className = s"${classType.headOption.getOrElse('r')}${abbr(p1)}_${abbr(p2)}".capitalize
   val tParams = "[@specialized(Int) A, @specialized(Int) B]"
-  def abbr(p: ParamConfig): String = p.modifier.split(' ').toSeq.map(_.headOption.getOrElse('n')).mkString + p.accessed.toString().head
-  //def access(param: ParamConfig, name: String) = if(param.accessed)
-  def decl(param: ParamConfig): String = param.aliasName.map(n => s"val $n = ${param.constructorName}\n").getOrElse("")
+  def abbr(p: ParamConfig): String = p.modifier.split(' ').toSeq.map(_.headOption.getOrElse('n')).mkString
+  def decl(param: ParamConfig): String = s"val ${param.aliasName} = ${param.constructorName}"
   def renderClass: String = s"""$classType class $className$tParams(${p1.modifier} ${p1.constructorName}: A, ${p2.modifier} a: B){
-    ${decl(p1)}${decl(p2)}
-  }"""
+                               |  ${decl(p1)}
+                               |  ${decl(p2)}
+                               |}""".stripMargin
   
   def accessConstr(p: ParamConfig) = Option(p).filterNot(p => p.modifier == "private val").filterNot(p => p.modifier == "" && classType == "").map(_.constructorName)
   def testConstrCh(p: ParamConfig, expected: String) = accessConstr(p).map(name => s"assert($expected == ch_$className.$name)")
   def testConstrI(p: ParamConfig, expected: String) = accessConstr(p).map(name => s"assert($expected == i_$className.$name)")
-  def testAliasCh(p: ParamConfig, expected: String) = p.aliasName.map(name => s"assert($expected == ch_$className.$name)")
-  def testAliasI(p: ParamConfig, expected: String) = p.aliasName.map(name => s"assert($expected == i_$className.$name)")
+  def testAliasCh(p: ParamConfig, expected: String) = Some(p.aliasName).map(name => s"assert($expected == ch_$className.$name)")
+  def testAliasI(p: ParamConfig, expected: String) = Some(p.aliasName).map(name => s"assert($expected == i_$className.$name)")
   def testExtractors = Some(s"""val $className(extracted1i_$className, extracted2i_$className) = i_$className
   |val $className(extracted1ch_$className, extracted2ch_$className) = ch_$className
   |assert(1 == extracted1i_$className)
@@ -33,20 +33,16 @@ case class TestCase(classType: String, p1: ParamConfig, p2: ParamConfig) {
     testAliasCh(p2, "'b'"),
   ).collect{ case Some(t) => t }
   def renderTests: String = (instantiateChar :: instantiateInt :: assertions).mkString("\n", "\n", "\n")
-  def instantiateChar = s"val ch_$className = new $className('a', 'b')"
-  def instantiateInt = s"val i_$className = new $className(1, 2)"
-  
+  def instantiateChar = s"val ch_$className = new $className('a', 'b')" //non-specialized variety
+  def instantiateInt = s"val i_$className = new $className(1, 2)" //specialized variety
 }
 
-case class ParamConfig(modifier: String, constructorName: String, aliasName: Option[String]) {
-  def accessed = aliasName.isDefined
-}
+case class ParamConfig(modifier: String, constructorName: String, aliasName: String)
 
 object Generator {
   def paramConfigurations(constructorName: String, aliasName: String) = for {
     modifier <- List("private val", "val", "")
-    accessed <- List(true, false)
-  } yield ParamConfig(modifier, constructorName, Option(aliasName).filter(_ => accessed))
+  } yield ParamConfig(modifier, constructorName, aliasName)
 
   def hasVal(p1: ParamConfig, p2: ParamConfig) = p1.modifier.contains("val") || p2.modifier.contains("val")